chore(release): cut 0.1.77

* Avoid empty OpenCode sessions during metadata probes

* Stabilize supervised restart regression test

.github/workflows/ci.yml

@@ -12,6 +12,11 @@ concurrency:
   group: ci-${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
+env:
+  # CI does not use the CUDA execution provider, and the onnxruntime-node
+  # postinstall download from NuGet is large enough to make npm ci flaky.
+  ONNXRUNTIME_NODE_INSTALL: skip
+
 jobs:
   format:
     runs-on: ubuntu-latest
@@ -99,8 +104,8 @@ jobs:
       - name: Install dependencies
         run: npm ci
 
-      - name: Install Claude Code CLI for provider tests
-        run: npm install -g @anthropic-ai/claude-code
+      - name: Install agent CLIs for provider tests
+        run: npm install -g @anthropic-ai/claude-code opencode-ai
 
       - name: Build highlight dependency
         run: npm run build --workspace=@getpaseo/highlight

.github/workflows/desktop-release.yml

@@ -40,7 +40,7 @@ on:
       rollout_hours:
         description: "Linear rollout duration in hours. Use 0 for instant rollout."
         required: false
-        default: "24"
+        default: "36"
         type: string
 
 concurrency:
@@ -51,7 +51,7 @@ env:
   SOURCE_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref_name }}
   CHECKOUT_REF: ${{ github.event_name == 'workflow_dispatch' && (github.event.inputs.checkout_ref || github.ref_name) || github.ref_name }}
   SHOULD_PUBLISH: ${{ github.event_name != 'workflow_dispatch' || github.event.inputs.publish != 'false' }}
-  ROLLOUT_HOURS: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.rollout_hours || '24' }}
+  ROLLOUT_HOURS: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.rollout_hours || '36' }}
   DESKTOP_PACKAGE_PATH: "packages/desktop"
 
 jobs:

.gitignore

@@ -6,6 +6,7 @@ build/
 dist/
 .next/
 out/
+result
 
 # Environment variables
 .env

CHANGELOG.md

@@ -1,22 +1,104 @@
 # Changelog
 
+## 0.1.77 - 2026-05-18
+
+### Added
+
+- **Slash commands to end and restart an agent.**
+- **Syntax highlighting for code blocks in chat.**
+- **Copy button on code blocks in chat.**
+- **Configurable terminal scrollback.** ([#1021](https://github.com/getpaseo/paseo/pull/1021) by [@32r4](https://github.com/32r4))
+- Assistant file links open at a specific line range when one is included.
+- Mode icons appear in the agent status menu. ([#1059](https://github.com/getpaseo/paseo/pull/1059) by [@32r4](https://github.com/32r4))
+- MCP exposes schedule update, logs, and run-once tools. ([#1032](https://github.com/getpaseo/paseo/pull/1032) by [@skevetter](https://github.com/skevetter))
+- Self-hosted relays support a separate TLS setting for the public endpoint, so the daemon can reach the relay over the LAN while the phone reaches it over the public secure address. ([#1045](https://github.com/getpaseo/paseo/pull/1045) by [@yzx9](https://github.com/yzx9))
+
+### Improved
+
+- User messages now have a distinct bubble fill for clearer chat hierarchy.
+- Closing a tab returns to its parent tab.
+- Diff rows show the full file path on hover. ([#1061](https://github.com/getpaseo/paseo/pull/1061) by [@Myriad-Dreamin](https://github.com/Myriad-Dreamin))
+- The CLI shows the remote daemon host when `ls` cannot connect. ([#1043](https://github.com/getpaseo/paseo/pull/1043) by [@mturac](https://github.com/mturac))
+- Nix install of the daemon is smaller. ([#966](https://github.com/getpaseo/paseo/pull/966) by [@ixxie](https://github.com/ixxie))
+- Nix install honors home-manager profile paths when inheriting the user PATH. ([#1040](https://github.com/getpaseo/paseo/pull/1040) by [@ixxie](https://github.com/ixxie))
+
+### Fixed
+
+- OpenCode probes no longer create empty sessions.
+- OpenCode custom commands no longer hang.
+- OpenCode session imports succeed across more environments.
+- Native diff rows expand correctly. ([#940](https://github.com/getpaseo/paseo/pull/940) by [@bolasblack](https://github.com/bolasblack))
+- Mobile sidebar interactions work correctly on web. ([#900](https://github.com/getpaseo/paseo/pull/900) by [@nikuscs](https://github.com/nikuscs))
+- Mobile web drag gestures fire reliably. ([#1048](https://github.com/getpaseo/paseo/pull/1048) by [@nikuscs](https://github.com/nikuscs))
+- Mobile web drag-and-drop activates correctly. ([#1048](https://github.com/getpaseo/paseo/pull/1048) by [@nikuscs](https://github.com/nikuscs))
+- iOS Safari no longer zooms when focusing the composer. ([#1048](https://github.com/getpaseo/paseo/pull/1048) by [@nikuscs](https://github.com/nikuscs))
+- Enter behavior in the mobile web composer is consistent. ([#1048](https://github.com/getpaseo/paseo/pull/1048) by [@nikuscs](https://github.com/nikuscs))
+- Composer no longer flickers when resizing with long prompts.
+- Inline code links in assistant messages open the correct file.
+- Host switcher popover is wide enough to show host names. ([#981](https://github.com/getpaseo/paseo/pull/981) by [@kongjiadongyuan](https://github.com/kongjiadongyuan))
+- Windows: importing existing sessions matches paths correctly. ([#1012](https://github.com/getpaseo/paseo/pull/1012) by [@kj1534](https://github.com/kj1534))
+
+## 0.1.76 - 2026-05-15
+
+### Added
+
+- **Chat timestamps and turn durations.** Every message shows when it was sent, and each turn surfaces how long the agent took.
+- **Auto Review permission mode for Claude Code and Codex.** Agents stop after each assistant turn for review instead of running unattended. ([#928](https://github.com/getpaseo/paseo/pull/928), [#963](https://github.com/getpaseo/paseo/pull/963) by [@bolasblack](https://github.com/bolasblack))
+- Surface Codex's context compaction events and the `/compact` command in chat.
+- Optional auto-archive for worktrees once their PR merges.
+- Paste a GitHub PR or issue URL into the composer to attach it as context.
+- Surface GitHub auto-merge actions in the PR hover card.
+- Show all PR check counts in the PR hover card.
+- Rename a project to disambiguate duplicates that share a folder name.
+- Confirm before archiving a worktree with uncommitted or unpushed work.
+- Claude Code now picks up models from `~/.claude/settings.json` so custom model lists show up in the model picker.
+- Local Claude Code settings (`.claude/settings.local.json`) apply per workspace.
+- Diagnostics for generic ACP providers surface in the model picker.
+- Allow setting fast mode for Paseo subagents ([#909](https://github.com/getpaseo/paseo/pull/909), [#910](https://github.com/getpaseo/paseo/pull/910) by [@kongjiadongyuan](https://github.com/kongjiadongyuan))
+
+### Improved
+
+- Surface Claude error messages in chat instead of ending the turn silently.
+- Workspace checkout picker auto-selects when a single PR is attached.
+- New workspace flow honors the currently checked-out branch when branching off. ([#909](https://github.com/getpaseo/paseo/pull/908) by [@sbtobb](https://github.com/sbtobb))
+- OpenCode models from console subscription providers now appear in the model picker. ([#917](https://github.com/getpaseo/paseo/pull/917) by [@t2o2](https://github.com/t2o2))
+- Cursor model picker reflects the models advertised by the Cursor ACP client. ([#958](https://github.com/getpaseo/paseo/pull/958) by [@chrisbanes](https://github.com/chrisbanes))
+
+### Fixed
+
+- iPad hardware Enter submits the composer. ([#919](https://github.com/getpaseo/paseo/pull/919) by [@kongjiadongyuan](https://github.com/kongjiadongyuan))
+- PR status falls back to a non-checks query for fine-grained GitHub tokens. ([#932](https://github.com/getpaseo/paseo/pull/932) by [@32r4](https://github.com/32r4))
+- ACP errors display as readable text instead of `[object Object]`.
+- OpenCode no longer hangs on retry when the upstream provider stalls.
+- Worktree ahead count is correct when the upstream branch has been deleted.
+- Branch-off worktrees track the correct upstream.
+- File changes view works on empty repositories with no commits yet.
+- Assistant message file links open the correct file.
+- Default thinking option matches the selected model's capabilities.
+- Shift+Enter works again in terminal input modes.
+- Duplicate project entries no longer appear after reopening a project.
+- Pi-backed sessions recover after a Copilot 413 instead of staying stuck.
+- Skip probing unrelated executable candidates when launching agents.
+- Relay E2EE reconnects cleanly under racing connect/disconnect.
+- Workspace kind stays in sync with project kind after reconfiguration.
+- zsh integration files install with usable runtime modes.
+- MCP worktree cache refreshes after create and archive. ([#911](https://github.com/getpaseo/paseo/pull/911) by [@kongjiadongyuan](https://github.com/kongjiadongyuan))
+
 ## 0.1.75 - 2026-05-12
 
 ### Added
 
 - Set the speech-to-text language used by dictation and voice mode from settings. ([#941](https://github.com/getpaseo/paseo/pull/941))
-- NixOS: `services.paseo.settings` renders declarative daemon config to disk, and typed `services.paseo.relay` options auto-wire the relay endpoint. ([#923](https://github.com/getpaseo/paseo/pull/923) by [@ixxie](https://github.com/ixxie))
-- NixOS: Paseo desktop is now packaged in the flake — `nix run github:getpaseo/paseo#desktop` launches the Electron app. ([#923](https://github.com/getpaseo/paseo/pull/923) by [@ixxie](https://github.com/ixxie))
 
 ### Fixed
 
 - Codex resume failures now surface as explicit errors instead of leaving the agent silently stuck. ([#947](https://github.com/getpaseo/paseo/pull/947))
 - Custom providers extending Codex now route correctly when they set a custom `OPENAI_BASE_URL`. ([#915](https://github.com/getpaseo/paseo/pull/915))
-- Copilot's **Allow All** mode (previously misnamed Autopilot) now actually suppresses tool, path, and URL permission prompts. ([#935](https://github.com/getpaseo/paseo/pull/935))
+- Fixed Copilot's **Allow All** mode (renamed from Autopilot) ([#935](https://github.com/getpaseo/paseo/pull/935))
 - Desktop: daemon startup no longer fails when a stale PID file is left next to a still-running daemon. ([#913](https://github.com/getpaseo/paseo/pull/913) by [@biaoma-ty](https://github.com/biaoma-ty))
-- iPhone HEIC photos now attach correctly from the image picker. ([#934](https://github.com/getpaseo/paseo/pull/934))
-- Scheduled agents now archive automatically after each run instead of piling up in the active list. ([#945](https://github.com/getpaseo/paseo/pull/945))
-- Windows: Codex command summaries show the underlying command instead of `pwsh`, `powershell`, or `cmd` wrappers. ([#931](https://github.com/getpaseo/paseo/pull/931) by [@32r4](https://github.com/32r4))
+- iPhone HEIC photos now attach correctly from the image picker ([#934](https://github.com/getpaseo/paseo/pull/934))
+- Scheduled agents now archive automatically after each run ([#945](https://github.com/getpaseo/paseo/pull/945))
+- Windows: Codex command summaries trim `pwsh`, `powershell`, or `cmd` wrappers. ([#931](https://github.com/getpaseo/paseo/pull/931) by [@32r4](https://github.com/32r4))
 - iPad: settings sidebar and main sidebar respect the top safe area in wide layouts. ([#922](https://github.com/getpaseo/paseo/pull/922), [#937](https://github.com/getpaseo/paseo/pull/937) by [@kongjiadongyuan](https://github.com/kongjiadongyuan))
 
 ## 0.1.74 - 2026-05-11

CLAUDE.md

@@ -21,26 +21,28 @@ This is an npm workspace monorepo:
 
 At the start of non-trivial work, list `docs/` and skim anything relevant to the task. When you learn something meta worth preserving — a gotcha, a convention, a workflow, a piece of system context that will outlive the current task — update an existing doc or propose a new one. Code-level facts belong in inline comments next to the code; system, process, and gotcha-level facts belong in `docs/`.
 
-| Doc                                                            | What's in it                                                                                  |
-| -------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
-| [docs/product.md](docs/product.md)                             | What Paseo is, who it's for, where it's going                                                 |
-| [docs/architecture.md](docs/architecture.md)                   | System design, package layering, WebSocket protocol, agent lifecycle, data flow               |
-| [docs/agent-lifecycle.md](docs/agent-lifecycle.md)             | Agent states, parent/child relationships, archive semantics, tabs vs archive, subagents track |
-| [docs/data-model.md](docs/data-model.md)                       | File-based JSON persistence, Zod schemas, atomic writes, no migrations                        |
-| [docs/glossary.md](docs/glossary.md)                           | Authoritative terminology — UI label wins, no synonyms                                        |
-| [docs/coding-standards.md](docs/coding-standards.md)           | Type hygiene, error handling, state design, React patterns, file organization                 |
-| [docs/design.md](docs/design.md)                               | Theme tokens — colors, fonts, spacing, radii, icons                                           |
-| [docs/unistyles.md](docs/unistyles.md)                         | Unistyles gotchas — `useUnistyles()` is forbidden, alternatives in order                      |
-| [docs/file-icons.md](docs/file-icons.md)                       | Material icon theme integration for the file explorer                                         |
-| [docs/providers.md](docs/providers.md)                         | Adding a new agent provider end-to-end                                                        |
-| [docs/custom-providers.md](docs/custom-providers.md)           | Custom provider config: Z.AI, Alibaba/Qwen, ACP agents, profiles, custom binaries             |
-| [docs/development.md](docs/development.md)                     | Dev server, build sync gotchas, CLI reference, agent state, Playwright MCP                    |
-| [docs/testing.md](docs/testing.md)                             | TDD workflow, determinism, real dependencies over mocks, test organization                    |
-| [docs/mobile-testing.md](docs/mobile-testing.md)               | Maestro and mobile test workflows                                                             |
-| [docs/ad-hoc-daemon-testing.md](docs/ad-hoc-daemon-testing.md) | Isolated in-process daemon test harness                                                       |
-| [docs/android.md](docs/android.md)                             | App variants, local/cloud builds, EAS workflows                                               |
-| [docs/release.md](docs/release.md)                             | Release playbook, draft releases, completion checklist                                        |
-| [SECURITY.md](SECURITY.md)                                     | Relay threat model, E2E encryption, DNS rebinding, agent auth                                 |
+| Doc                                                            | What's in it                                                                                                                   |
+| -------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| [docs/product.md](docs/product.md)                             | What Paseo is, who it's for, where it's going                                                                                  |
+| [docs/architecture.md](docs/architecture.md)                   | System design, package layering, WebSocket protocol, agent lifecycle, data flow                                                |
+| [docs/agent-lifecycle.md](docs/agent-lifecycle.md)             | Agent states, parent/child relationships, archive semantics, tabs vs archive, subagents track                                  |
+| [docs/data-model.md](docs/data-model.md)                       | File-based JSON persistence, Zod schemas, atomic writes, no migrations                                                         |
+| [docs/glossary.md](docs/glossary.md)                           | Authoritative terminology — UI label wins, no synonyms                                                                         |
+| [docs/coding-standards.md](docs/coding-standards.md)           | Type hygiene, error handling, state design, React patterns, file organization                                                  |
+| [docs/design.md](docs/design.md)                               | Theme tokens — colors, fonts, spacing, radii, icons                                                                            |
+| [docs/hover.md](docs/hover.md)                                 | Hover — the canonical pattern (plain View + onPointerEnter/Leave, separate inner Pressable) and the three ways agents break it |
+| [docs/unistyles.md](docs/unistyles.md)                         | Unistyles gotchas — `useUnistyles()` is forbidden, alternatives in order                                                       |
+| [docs/file-icons.md](docs/file-icons.md)                       | Material icon theme integration for the file explorer                                                                          |
+| [docs/providers.md](docs/providers.md)                         | Adding a new agent provider end-to-end                                                                                         |
+| [docs/custom-providers.md](docs/custom-providers.md)           | Custom provider config: Z.AI, Alibaba/Qwen, ACP agents, profiles, custom binaries                                              |
+| [docs/development.md](docs/development.md)                     | Dev server, build sync gotchas, CLI reference, agent state, Playwright MCP                                                     |
+| [docs/rpc-namespacing.md](docs/rpc-namespacing.md)             | WebSocket RPC naming convention — dotted namespaces and `.request`/`.response` pairs                                           |
+| [docs/testing.md](docs/testing.md)                             | TDD workflow, determinism, real dependencies over mocks, test organization                                                     |
+| [docs/mobile-testing.md](docs/mobile-testing.md)               | Maestro and mobile test workflows                                                                                              |
+| [docs/ad-hoc-daemon-testing.md](docs/ad-hoc-daemon-testing.md) | Isolated in-process daemon test harness                                                                                        |
+| [docs/android.md](docs/android.md)                             | App variants, local/cloud builds, EAS workflows                                                                                |
+| [docs/release.md](docs/release.md)                             | Release playbook, draft releases, completion checklist                                                                         |
+| [SECURITY.md](SECURITY.md)                                     | Relay threat model, E2E encryption, DNS rebinding, agent auth                                                                  |
 
 ## Quick start
 
@@ -86,6 +88,7 @@ See [docs/development.md](docs/development.md) for full setup, build sync requir
     - **No defensive branches scattered through the feature.** Capability detection happens in one place; downstream code reads a clean shape.
     - **Capability flags live in `server_info.features.*`** with a single `// COMPAT(featureName): added in v0.1.X, drop the gate when floor >= v0.1.X` comment marking the cleanup site.
     - Existing functionality keeps working across versions — that's the protocol contract doing its job. New-feature degradation is not the goal.
+    - **New RPCs use dotted namespaces with direction suffixes.** Follow [docs/rpc-namespacing.md](docs/rpc-namespacing.md): `domain.provider.operation.request` pairs with `domain.provider.operation.response`. Existing flat RPC names will migrate over time; don't add new ones.
 
 - **All back-compat shims are tagged and dated for cleanup.** Every shim that exists for old-client/old-daemon support carries a `COMPAT(name)` comment with the version it was added in and a target removal date (typically 6 months out). One grep — `rg "COMPAT\("` — should produce the full list of cleanup work. Don't bury back-compat in untagged `??`-fallbacks or optional-chain tunnels — that's how it stops being deletable.
 

CONTRIBUTING.md

@@ -1,63 +1,32 @@
 # Contributing to Paseo
 
-## How this project works
+Paseo is an opinionated product maintained by one person.
 
-Paseo is opinionated and maintained by one person. I read every issue and PR myself, so review cost is real.
+I read every issue and PR myself, and I am selective about what contributions I accept.
 
-- **Feature requests are welcome.** Open an issue describing the problem. Get a thumbs up before writing code. Big ideas are better discussed in [Discord](https://discord.gg/jz8T2uahpH) first.
-- **Objective bug fixes don't need a prior issue.** Reference what's broken, keep the diff narrow, open the PR.
-- **The product stays lean.** I'll close, scope down, or rewrite PRs that add surface area I don't want to maintain, even if the code is fine.
+Good ideas still need to fit the shape of the product: a PR can be technically correct and still not belong in Paseo.
 
-## Reporting bugs
+Core product, design, architecture, and workflow changes are not accepted.
 
-Fill in the bug report form. The fields are there because asking back for the surface, version, provider config, and logs is where most of my time on a bad report goes.
+Follow these rules if you want your PR to be merged:
 
-- **Full logs, not AI summaries.** Use an agent to grab the relevant log section if you want, but paste the raw log. Agents routinely correlate adjacent lines as cause-and-effect when they aren't, and once a report is filtered through that the signal I need is gone.
-- **Agents for information gathering, not diagnosis.** A bot that grabs your daemon log, version, and OS is helpful. A bot that submits its own theory of the bug is noise 99% of the time.
-- **Screenshots or video for UI bugs.** A 10-second recording beats a paragraph.
-- **One bug per issue.** Three findings, three issues.
+- Keep it to one focused change
+- Link to an issue
+- Explain the problem you're solving
+- Include repro steps if it's a bug
+- Include QA/testing evidence
+- UI changes need screenshots or video for every affected platform: iOS, Android, desktop, and web
+- If you only tested one platform, say that clearly
 
-## Before you start
+Your PR will be closed if you do any of these:
 
-- [README.md](README.md)
-- [docs/architecture.md](docs/architecture.md)
-- [docs/development.md](docs/development.md)
-- [docs/coding-standards.md](docs/coding-standards.md)
-- [docs/testing.md](docs/testing.md)
-- [CLAUDE.md](CLAUDE.md)
+- Bundle unrelated changes
+- Fail basic checks like typecheck, formatting or linting
+- Make product, design, or architecture changes without prior discussion
+- Submit no evidence of testing
+- Skip the linked issue
+- Clearly fully AI-generated PR
 
-## What is most helpful
+## AI assistance
 
-- bug fixes (especially Windows and Linux)
-- regression fixes
-- doc improvements
-- packaging and platform fixes
-- focused UX improvements that fit the product direction
-- tests that lock down important behavior
-
-## Development setup
-
-```bash
-npm run dev               # daemon + expo
-npm run dev:server
-npm run dev:app
-npm run dev:desktop
-npm run dev:website
-```
-
-[docs/development.md](docs/development.md) covers build sync, local state, and ports. Coding rules live in [docs/coding-standards.md](docs/coding-standards.md).
-
-## Pull requests
-
-- One focused change per PR. Split unrelated cleanups out.
-- Reference the issue you're fixing, unless it's a small objective bug.
-- UI changes need screenshots or video on every affected platform (mobile, web, desktop). Things that look fine on one surface regularly break on another.
-- `npm run typecheck` and `npm run lint` must pass.
-- Don't make breaking WebSocket or protocol changes. Old apps and old daemons coexist in the wild.
-- The PR template applies whether you used the web UI or `gh pr create`. Don't strip it out.
-
-**On AI-assisted PRs.** AI in the loop is fine. The bar is whether _you_ tested the change and can explain why it works. A confident wall of AI prose with no evidence of testing is a red flag and usually gets closed. If you don't fully understand why your fix works, say so directly. "Here's the repro before and after, not sure why this fixes it" is much better than a fabricated explanation.
-
-## Forks are fine
-
-If you want to explore a different product direction, fork. Paseo is open source on purpose. Not every idea needs to land here to be valuable.
+AI in the loop is fine. The bar is whether _you_ tested the change and can explain why it works. A confident wall of AI prose with no evidence of testing is a red flag and will get closed.

docs/android.md

@@ -27,12 +27,12 @@ Or from `packages/app`:
 
 ```bash
 # Debug
-APP_VARIANT=development npx expo prebuild --platform android --non-interactive
-APP_VARIANT=development npx expo run:android --variant=debug
+npx cross-env APP_VARIANT=development expo prebuild --platform android --non-interactive
+npx cross-env APP_VARIANT=development expo run:android --variant=debug
 
 # Release
-APP_VARIANT=production npx expo prebuild --platform android --non-interactive
-APP_VARIANT=production npx expo run:android --variant=release
+npx cross-env APP_VARIANT=production expo prebuild --platform android --non-interactive
+npx cross-env APP_VARIANT=production expo run:android --variant=release
 
 # Clear generated Android project
 rm -rf android

docs/architecture.md

@@ -107,7 +107,7 @@ Enables remote access when the daemon is behind a firewall.
 - Relay server is zero-knowledge — it routes encrypted bytes, cannot read content
 - Client and daemon channels with identical API (`createClientChannel`, `createDaemonChannel`)
 - Pairing via QR code transfers the daemon's public key to the client
-- Self-hosted relays opt into TLS with `daemon.relay.useTls` or `PASEO_RELAY_USE_TLS=true`
+- Self-hosted relays opt into TLS with `daemon.relay.useTls` or `PASEO_RELAY_USE_TLS=true`; the public (client-facing) TLS setting can be overridden independently via `daemon.relay.publicUseTls` or `PASEO_RELAY_PUBLIC_USE_TLS`
 
 See [SECURITY.md](../SECURITY.md) for the full threat model.
 
@@ -146,6 +146,8 @@ There is no dedicated welcome message; the server emits a `status` session messa
 
 **Top-level WS envelopes** are `hello`, `recording_state`, `ping`/`pong`, and `session` (which wraps the rich union of session messages).
 
+New session RPCs use dotted names with `.request` and `.response` suffixes, such as `checkout.github.set_auto_merge.request` and `checkout.github.set_auto_merge.response`. See [rpc-namespacing.md](rpc-namespacing.md) for the convention and migration rules for older flat RPC names.
+
 **Notable session message types:**
 
 - `agent_update` — Agent state changed (status, title, labels)
@@ -205,6 +207,7 @@ initializing → idle ⇄ running
 
 - **AgentManager** is the source of truth for agent state and broadcasts updates to all subscribers
 - Timeline is append-only with epochs (each run starts a new epoch). Storage uses sequence numbers for client-side dedup; the default fetch page is 200 items
+- Timeline row `timestamp` values are canonical daemon-owned timestamps. Providers may supply original replay timestamps, but clients must not guess timestamp trust or hide time UI based on local clock heuristics.
 - Events stream to all subscribed clients in real time
 - Agent state persists to `$PASEO_HOME/agents/{cwd-with-dashes}/{agent-id}.json` (timeline rows live alongside the record)
 

docs/custom-providers.md

@@ -366,6 +366,14 @@ Required fields for ACP providers:
 - `label`
 - `command` — the command to spawn the agent process (must support ACP over stdio)
 
+### 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.
+
+For package-runner commands such as `npx -y @google/gemini-cli --acp`, the version probe keeps the package spec and runs `npx -y @google/gemini-cli --version`. This diagnoses the actual agent package instead of only proving that `npx` exists.
+
+ACP probes use short timeouts and browser-suppression environment variables so agents that enter an auth/browser flow fail as a diagnostic error instead of hanging the provider screen.
+
 ### Example: Google Gemini CLI
 
 [Gemini CLI](https://github.com/google-gemini/gemini-cli) supports ACP via the `--acp` flag.
@@ -528,6 +536,12 @@ Each entry in the `models` array:
 | `description` | `string`  | No       | Short description                   |
 | `isDefault`   | `boolean` | No       | Mark as the default thinking option |
 
+### Claude settings.json model discovery
+
+The built-in `claude` provider appends concrete model IDs from `~/.claude/settings.json` to its first-party Claude model list. Paseo reads the top-level `model` field and these `env` keys: `ANTHROPIC_MODEL`, `ANTHROPIC_SMALL_FAST_MODEL`, `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, and `ANTHROPIC_DEFAULT_HAIKU_MODEL`.
+
+This lets users who already configured Claude Code for Bedrock, OpenRouter, ollama, Z.AI, or another Anthropic-compatible gateway select the exact model ID in Paseo. `agents.providers.claude.models` is still supported and is additive for the built-in Claude provider; duplicate IDs are de-duplicated.
+
 ### Gotcha: `extends: "claude"` with third-party endpoints
 
 When a custom provider extends `"claude"` but points `ANTHROPIC_BASE_URL` at a non-Anthropic API (Z.AI, Alibaba/Qwen, proxies), the Claude Agent SDK may try to use Anthropic-only server-side tools like `WebSearch`. Third-party APIs don't support these tools, causing errors.

docs/data-model.md

@@ -140,7 +140,7 @@ Single file, validated with `PersistedConfigSchema`.
     hostnames: true | string[],   // legacy alias `allowedHosts` is migrated on load
     mcp: { enabled: boolean, injectIntoAgents: boolean },
     cors: { allowedOrigins: string[] },
-    relay: { enabled: boolean, endpoint: string, publicEndpoint: string, useTls: boolean },
+    relay: { enabled: boolean, endpoint: string, publicEndpoint: string, useTls: boolean, publicUseTls: boolean },
     auth: { password: string }    // bcrypt hash, optional
   },
   app: {
@@ -362,6 +362,11 @@ Array of project records.
 | `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,
+preferring remote-keyed project IDs such as `remote:github.com/owner/repo`, then archiving the
+emptied duplicate.
+
 ---
 
 ## 7. Workspace Registry

docs/design.md

@@ -216,7 +216,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, archive, and any future destructive action are confirmed.
+- 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.
 - 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

@@ -37,6 +37,12 @@ PASEO_DEV_RESET_HOME=1 npm run dev            # clear and reseed the derived wor
 
 In any worktree-style or portless setup, never assume default ports.
 
+### Desktop renderer profiling
+
+`npm run dev:desktop` starts Electron with Chromium remote debugging enabled on
+`http://127.0.0.1:9223` so renderer CPU profiles can be captured through CDP.
+Override the port with `PASEO_ELECTRON_REMOTE_DEBUGGING_PORT` when `9223` is busy.
+
 ### Daemon logs
 
 Check `$PASEO_HOME/daemon.log` for daemon logs. The default level is `info`; set

docs/hover.md

@@ -0,0 +1,138 @@
+# Hover
+
+Read this before writing any hover code. Every hover regression we ship is one of the three failure modes below, and every one of them is solved by the same canonical pattern. The pattern is hardwon — it survived every other shape we tried — so copy it, don't reinvent it.
+
+## The pattern
+
+The canonical implementation lives in `packages/app/src/components/sidebar-workspace-list.tsx`, in the workspace row (around line 1369). When in doubt, open that file and copy the shape.
+
+```tsx
+//
+//   ┌─ Plain View. Tracks hover via pointerenter/pointerleave.
+//   │
+<View
+  style={styles.workspaceRowContainer}
+  onPointerEnter={handlePointerEnter}
+  onPointerLeave={handlePointerLeave}
+>
+  <Pressable                          // ┐ Separate inner Pressable.
+    onPress={handlePress}             // │ Handles press only.
+    onPressIn={...}                   // │ Never has onHoverIn/onHoverOut.
+    onPressOut={...}                  // ┘
+    style={workspaceRowStyle}
+  >
+    <View style={styles.workspaceRowMain}>
+      <View style={styles.workspaceRowLeft}>…</View>
+      <WorkspaceRowRightGroup isHovered={isHovered} />
+      {/*                    └─ Reveals content based on hover state. */}
+    </View>
+  </Pressable>
+</View>
+```
+
+Five things make this work. Every one of them matters.
+
+1. **Hover lives on a plain `View`, not a `Pressable`.** `Pressable` carries its own internal hover state machine. Nested `Pressable`s fight over it. A plain `View` just dispatches DOM events — no state machine, no fighting.
+2. **Press lives on a _separate_ inner `Pressable`.** Hover and press never share an element. The two state machines never see each other.
+3. **`onPointerEnter` / `onPointerLeave` are non-bubbling**, mouseenter-style by W3C spec. They fire only when crossing the outer `View`'s bounding box. Crossing into descendants — including descendant `Pressable`s (the kebab menu's buttons, a copy button, a tooltip target) — does **not** fire `pointerleave`. This is why nesting `Pressable`s inside is safe.
+4. **The row has a fixed `minHeight`.** When content swaps in on hover (kebab replacing a diff stat), both occupy the same fixed slot. Zero layout shift, zero geometry flicker.
+5. **The outer `View` has nothing but `position: relative`.** It exists only to be the hover target. All real layout lives on the inner `Pressable`. The hover-tracker is a sealed envelope around the row; layout changes inside it never leak out and re-enter through the side.
+
+That's the whole pattern. Internalize it.
+
+## When you skip the pattern, here is what breaks
+
+### Failure mode 1 — Nested Pressables fight over hover state
+
+If you put `onHoverIn` / `onHoverOut` on a `Pressable` that has another `Pressable` anywhere inside it (a copy button, an icon button, a nested action), the moment the cursor moves onto the inner `Pressable`, the inner one's hover state machine claims hover and the outer one's `onHoverOut` fires. Your reveal state flips off. The reveal hides. The cursor is no longer over the hidden reveal, so it ends up back over the trigger area. The outer's `onHoverIn` fires. Loop.
+
+This is the most common hover bug shipped in this codebase, by a wide margin. It is what the workspace row is structured to avoid. The fix is not "be clever about handlers" — it's "don't put hover on a Pressable that contains other Pressables."
+
+> **Rule:** the hover-tracking element is a plain `View` with `onPointerEnter` / `onPointerLeave`. Any `Pressable`s — including ones you forgot are Pressables, like `TurnCopyButton`, icon buttons, anything that handles a tap — live inside it.
+
+### Failure mode 2 — The hovered state changes the trigger's geometry
+
+Symptom: you hover a button, it changes appearance, then flickers between hovered and not-hovered without the cursor moving.
+
+Cause: the hover state changed the size or position of the trigger. The cursor was on the original element; the new layout shifts or shrinks it out from under the cursor; `onHoverOut` fires; state reverts; original layout returns; cursor is back over the trigger; `onHoverIn` fires; loop.
+
+Common variants:
+
+- Hover state changes the trigger's `width`, `height`, `padding`, or `borderWidth`.
+- Hover state mounts/unmounts a child that pushes the trigger to a new position.
+- Hover state swaps the trigger for a different element type, remounting it.
+
+Fixes, in preferred order:
+
+1. **Don't change the trigger's outer geometry on hover.** Change colors, opacity, borders that don't take layout space (`outlineWidth` on web, absolutely positioned overlays), or child content that fits inside the same fixed box. Never change `width`, `height`, `padding`, or `borderWidth` of the hover target itself.
+2. **Hide with `opacity` + `pointerEvents`, not conditional rendering**, when the hidden element lives inside the trigger. Mounting/unmounting on hover reflows the layout under the cursor.
+3. **Pin the hit area.** Set a fixed `minHeight` / `minWidth` on the trigger so internal swaps (icon-A becomes icon-B on hover) leave the bounding box unchanged. The workspace row's `minHeight: 36` is what makes the kebab/diff-stat swap stable.
+
+### Failure mode 3 — Revealed content lives outside the hover trigger
+
+If hovering element A reveals element B, B must be **inside** A's hover trigger. If B is a sibling, the moment the cursor moves from A toward B it crosses out of A's bounding box, `pointerleave` fires, B disappears.
+
+Wrong:
+
+```tsx
+<View>
+  <View onPointerEnter={...} onPointerLeave={...}>     {/* hover trigger */}
+    <Bubble />
+  </View>
+  <TrailingRow />                                       {/* OUTSIDE — sibling, not child */}
+</View>
+```
+
+Right:
+
+```tsx
+<View onPointerEnter={...} onPointerLeave={...}>      {/* hover trigger */}
+  <Bubble />
+  <TrailingRow />                                      {/* INSIDE — child */}
+</View>
+```
+
+Any gap between A and B (margins between siblings inside the same parent) is part of the parent's bounding box, so the cursor stays inside the hover region while crossing it. No bridge needed.
+
+If A and B genuinely can't share a parent — B portals into a different layer, floats above other content — see [Section: real gaps](#real-gaps-with-floating-panels) below.
+
+## Native fallback
+
+Hover doesn't exist on touch devices. Anything you hide behind hover must have a non-hover path on native and compact layouts:
+
+```tsx
+const showControls = isHovered || isNative || isCompact;
+```
+
+`isNative` and `isCompact` come from `@/constants/platform` and `@/constants/layout`. Don't use `Platform.OS === "ios"` as a proxy.
+
+`onPointerEnter` / `onPointerLeave` are DOM events. They do not fire on native. You do not need to gate them — on native, hover is unreachable anyway and visibility is driven by `isNative` / `isCompact` in your show-the-controls expression above. This is why the workspace row's pointer events are not wrapped in `if (isWeb)`.
+
+## What about `Pressable.onHoverIn` / `onHoverOut`?
+
+It's fine when a `Pressable` styles **itself** based on its own hover — for example, an icon button that changes color on hover. That's self-contained. The render-prop `<Pressable style={({ hovered }) => ...}>` does the same thing more cleanly and is the preferred form.
+
+It is **not** fine for tracking hover to drive state **outside** that `Pressable` (revealing a sibling, opening a tooltip, showing a kebab) when there is any other `Pressable` inside — because that's Failure Mode 1.
+
+Heuristic: if your hover state is going to be `useState`'d and read by anything other than the same `Pressable`'s own style, do not use `onHoverIn` / `onHoverOut`. Use the canonical pattern.
+
+## Real gaps with floating panels
+
+Sometimes the revealed content can't live inside the trigger — a hover card portals into a different layer, a tooltip floats above other content, a popover renders into a `Portal`. There's a real visual gap the user has to cross with the cursor.
+
+For this case, use `useHoverSafeZone` (`packages/app/src/hooks/use-hover-safe-zone.ts`). It computes a rectangular "bridge" between the trigger and the content; while the pointer is inside trigger, content, or the bridge, the card stays open. A short grace timer absorbs jitter at the edges. The canonical caller is `packages/app/src/components/workspace-hover-card.tsx`.
+
+Don't roll your own. The math is annoying, the edge cases (pointer leaves window, drag in progress, content unmounts) are subtle, and we already paid for the hook.
+
+## Pre-PR checklist
+
+Before opening a PR that touches hover:
+
+- [ ] Hover-tracking is on a plain `View` with `onPointerEnter` / `onPointerLeave`, **not** on a `Pressable` that wraps anything pressable.
+- [ ] Any press behavior lives on a separate inner `Pressable` that does not have `onHoverIn` / `onHoverOut`.
+- [ ] The hover trigger's bounding box contains every element the user might mouse into while interacting with the feature.
+- [ ] Hovered state does **not** change the trigger's outer geometry (`width`, `height`, `padding`, `borderWidth`, mount/unmount of siblings that shift it). Internal swaps fit inside a fixed `minHeight` / `minWidth`.
+- [ ] Revealed content inside the trigger uses `opacity` + `pointerEvents`, not conditional rendering, if mounting it would reflow the trigger.
+- [ ] Visibility on native and compact layouts works without hover (`isHovered || isNative || isCompact`).
+- [ ] If the revealed content sits in a separate layer (portal, floating panel), `useHoverSafeZone` is wired up.
+- [ ] You opened the dev server, hovered the trigger, and slowly moved the mouse along **every** revealed element — including any visible gaps — without losing hover state.

docs/providers.md

@@ -16,6 +16,18 @@ Implement the `AgentClient` and `AgentSession` interfaces from `agent-sdk-types.
 
 Existing direct providers: `claude` (in `providers/claude/agent.ts`), `codex` (`codex-app-server-agent.ts`), `opencode` (`opencode-agent.ts`), `pi` (`pi-direct-agent.ts`). The dev-only `mock` provider (`mock-load-test-agent.ts`) is also direct.
 
+Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.listModels`, `listModes`, `listCommands`, or `listFeatures` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs.
+
+---
+
+## Provider Snapshot Refresh Contract
+
+The daemon keeps one global provider snapshot, keyed to the home directory, for settings, selectors, and old model/mode list requests. Snapshot reads may probe providers only while the snapshot is cold. Once an entry is warm, its `ready`, `error`, or `unavailable` state stays cached until the user forces a refresh from settings/provider management.
+
+Do not add TTL revalidation, focus-triggered refreshes, selector-open refreshes, or config-reload refreshes. Registry/config replacement may update visible metadata such as label, description, default mode, enabled state, and provider membership, but it must not spawn provider processes. If a provider needs to be re-probed after a config change, route that through the explicit settings refresh path.
+
+Boundary tests should assert observable behavior: cold reads may call provider availability/model/mode discovery; warm reads and registry replacement must not; explicit full or targeted refreshes must.
+
 ---
 
 ## ACP Provider Checklist

docs/release.md

@@ -61,7 +61,7 @@ Use the beta path when you need to:
 
 ## Staged rollout (stable channel)
 
-Stable desktop releases go out via a linear time-based rollout: 0% admitted when the updater manifests appear, 100% admitted 24 hours later, linear ramp in between. Beta releases bypass the rollout entirely — beta users always receive updates immediately.
+Stable desktop releases go out via a linear time-based rollout: 0% admitted when the updater manifests appear, 100% admitted 36 hours later, linear ramp in between. Beta releases bypass the rollout entirely — beta users always receive updates immediately.
 
 The rollout is driven by a `rolloutHours` field stamped into the GitHub Release manifests (`latest-mac.yml`, `latest-linux.yml`, `latest.yml`) by the `finalize-rollout` job in `desktop-release.yml`.
 
@@ -74,16 +74,16 @@ Updater clients only discover a release through those `.yml` manifests, so there
 
 ### Default behavior
 
-`npm run release:patch` → tag push → 24h ramp. No extra action needed.
+`npm run release:patch` → tag push → 36h ramp. No extra action needed.
 
-The `rollout_hours` input on `desktop-release.yml` is **only read on `workflow_dispatch`** — tag-push runs always default to 24. To get any other rollout duration on a fresh release, use the post-publish flip below.
+The `rollout_hours` input on `desktop-release.yml` is **only read on `workflow_dispatch`** — tag-push runs always default to 36. To get any other rollout duration on a fresh release, use the post-publish flip below.
 
 ### Instant-admit release (rollout_hours=0 from publish)
 
 For a fresh release that should admit everyone immediately (low-risk change, doc-only, hotfix, or just a release you want out fast), cut the release normally and queue the rollout flip immediately after:
 
 ```bash
-# 1. Cut and publish (default 24h ramp from tag push).
+# 1. Cut and publish (default 36h ramp from tag push).
 npm run release:patch
 
 # 2. Immediately queue the flip — runs as soon as finalize-rollout completes.
@@ -92,7 +92,7 @@ gh workflow run desktop-rollout.yml \
   -f rollout_hours=0
 ```
 
-**Why this is gap-free:** `desktop-release.yml`'s `finalize-rollout` job and `desktop-rollout.yml` share the concurrency group `desktop-rollout-<tag>`. Dispatching `desktop-rollout.yml` while the tag-push pipeline is still running queues it safely behind `finalize-rollout`. The first public manifests already carry `rolloutHours=24`, then `desktop-rollout.yml` flips them to `rolloutHours=0` shortly afterward. The renderer polls every 30 minutes, so active stable users pick up the new manifest on their next check.
+**Why this is gap-free:** `desktop-release.yml`'s `finalize-rollout` job and `desktop-rollout.yml` share the concurrency group `desktop-rollout-<tag>`. Dispatching `desktop-rollout.yml` while the tag-push pipeline is still running queues it safely behind `finalize-rollout`. The first public manifests already carry `rolloutHours=36`, then `desktop-rollout.yml` flips them to `rolloutHours=0` shortly afterward. The renderer polls every 30 minutes, so active stable users pick up the new manifest on their next check.
 
 Run the dispatch right after `release:patch` returns. Don't wait for the tag-push CI to finish.
 
@@ -132,7 +132,7 @@ gh workflow run desktop-release.yml \
   -f rollout_hours=6
 ```
 
-This does **not** apply to fresh releases cut via `npm run release:patch` — that path always tag-pushes and stamps 24. For a fresh release with a custom ramp, cut normally and then dispatch `desktop-rollout.yml` (same pattern as the instant-admit flow above, with your chosen `rollout_hours`).
+This does **not** apply to fresh releases cut via `npm run release:patch` — that path always tag-pushes and stamps 36. For a fresh release with a custom ramp, cut normally and then dispatch `desktop-rollout.yml` (same pattern as the instant-admit flow above, with your chosen `rollout_hours`).
 
 ### Releasing during an active rollout
 

docs/rpc-namespacing.md

@@ -0,0 +1,84 @@
+# RPC Namespacing
+
+New WebSocket session RPCs use dotted names with the direction as the final segment:
+
+```ts
+checkout.github.set_auto_merge.request;
+checkout.github.set_auto_merge.response;
+```
+
+The namespace reads left to right:
+
+- Domain: `checkout`
+- Provider or subsystem: `github`
+- Operation: `set_auto_merge`
+- Direction: `request` or `response`
+
+Use dots, not slashes. Dots are protocol namespaces; slashes imply paths or transport routing.
+
+## Request/Response Pairs
+
+For ordinary correlated RPCs, a `.request` has a matching `.response` with the same prefix. The daemon client may derive the response type mechanically:
+
+```ts
+checkout.github.set_auto_merge.request;
+// -> checkout.github.set_auto_merge.response
+```
+
+Most new RPCs should follow this shape. If a request does not have a one-to-one response, call that out in the code near the schema.
+
+## Message Shape
+
+Requests keep their parameters at the top level:
+
+```ts
+{
+  type: "checkout.github.set_auto_merge.request",
+  cwd: "/repo",
+  enabled: true,
+  mergeMethod: "squash",
+  requestId: "req_123"
+}
+```
+
+Responses put correlated result data under `payload`:
+
+```ts
+{
+  type: "checkout.github.set_auto_merge.response",
+  payload: {
+    cwd: "/repo",
+    enabled: true,
+    success: true,
+    error: null,
+    requestId: "req_123"
+  }
+}
+```
+
+Keep `requestId` in both request and response payloads. It is the correlation key.
+
+## Provider Namespacing
+
+Provider-specific behavior belongs under the provider segment:
+
+- `checkout.github.*` for GitHub-specific checkout operations
+- `checkout.gitlab.*` for future GitLab-specific checkout operations
+
+Do not put GitHub-specific enums or semantics into generic checkout RPC names. A generic RPC should only exist when the behavior is genuinely provider-neutral.
+
+## Compatibility
+
+The existing flat RPC names remain part of the protocol until they are intentionally migrated:
+
+```ts
+checkout_pr_merge_request;
+checkout_pr_merge_response;
+```
+
+Do not add new flat names. When migrating old RPCs, keep protocol compatibility rules in mind:
+
+- Add the new names first.
+- Gate new feature behavior through `server_info.features.*` when an old host cannot support it.
+- Keep old names accepted until the compatibility window expires.
+- Mark shims with `COMPAT(...)` and a removal date.

flake.nix

@@ -36,7 +36,7 @@
           paseo = paseo;
         }
         // nixpkgs.lib.optionalAttrs isLinux {
-          desktop = pkgs.callPackage ./nix/desktop-package.nix { };
+          desktop = pkgs.callPackage ./nix/desktop-package.nix { inherit paseo; };
         }
       );
 

lefthook.yml

@@ -3,6 +3,8 @@ pre-commit:
   jobs:
     - name: format
       glob: "*.{css,js,json,jsonc,jsx,md,ts,tsx,yaml,yml}"
+      exclude:
+        - "**/package-lock.json"
       run: npm run format:check:files -- {staged_files}
     - name: lint
       glob: "*.{js,jsx,ts,tsx}"

nix/desktop-package.nix

@@ -9,10 +9,11 @@
   makeDesktopItem,
   electron,
   libuv,
-  # Shares the daemon's npm-deps hash — same package-lock.json, same fetcher.
-  # Override via `.override { npmDepsHash = "..."; }` if your nixpkgs computes a
-  # different value.
-  npmDepsHash ? lib.fileContents ./npm-deps.hash,
+  # Reuse the daemon's prebuilt npm-deps FOD. Same lockfile, same content —
+  # without this, the desktop drv produces a separately-named store path
+  # (`paseo-desktop-<v>-npm-deps`) and refetches the entire registry. Override
+  # the upstream hash via `paseo.override { npmDepsHash = "..."; }`.
+  paseo,
 }:
 
 buildNpmPackage rec {
@@ -21,7 +22,8 @@ buildNpmPackage rec {
 
   src = lib.cleanSourceWith {
     src = ./..;
-    filter = path: type:
+    filter =
+      path: type:
       let
         baseName = builtins.baseNameOf path;
         relPath = lib.removePrefix (toString ./..) path;
@@ -42,7 +44,7 @@ buildNpmPackage rec {
   };
 
   nodejs = nodejs_22;
-  inherit npmDepsHash;
+  inherit (paseo) npmDeps;
 
   # Prevent onnxruntime-node's install script from running during automatic
   # npm rebuild. We manually rebuild only node-pty in buildPhase.

nix/module.nix

@@ -135,8 +135,9 @@ in
 
         When Paseo runs as a real user (not the default system user), AI agents
         need access to the user's tools (git, ssh, etc.). This adds the user's
-        NixOS profile and system paths so agents can use them without manually
-        setting PATH.
+        NixOS profile, home-manager profile (`~/.nix-profile/bin` and
+        `~/.local/state/nix/profile/bin`), and system paths so agents can use
+        them without manually setting PATH.
 
         Enabled by default when `user` is set to a non-default value.
       '';
@@ -221,17 +222,31 @@ in
         NODE_ENV = "production";
         PASEO_HOME = cfg.dataDir;
         PASEO_LISTEN = "${cfg.listenAddress}:${toString cfg.port}";
-      } // lib.optionalAttrs cfg.inheritUserEnvironment {
-        # mkForce overrides the default PATH from NixOS's systemd module (which
-        # only includes store paths for coreutils/grep/sed/systemd). Our PATH
-        # includes /run/current-system/sw/bin which is a superset of those.
-        PATH = lib.mkForce (lib.concatStringsSep ":" [
-          "/etc/profiles/per-user/${cfg.user}/bin"
-          "/run/current-system/sw/bin"
-          "/run/wrappers/bin"
-          "/nix/var/nix/profiles/default/bin"
-        ]);
-      } // lib.optionalAttrs (cfg.hostnames == true) {
+      } // lib.optionalAttrs cfg.inheritUserEnvironment (
+        let
+          # Match dataDir's convention. We can't read users.users.<name>.home
+          # because the user may be managed outside NixOS.
+          userHome = "/home/${cfg.user}";
+        in {
+          # mkForce overrides the default PATH from NixOS's systemd module (which
+          # only includes store paths for coreutils/grep/sed/systemd). When the
+          # daemon runs as a real user, also include home-manager profile paths
+          # so user-installed CLIs (claude, opencode, codex, ...) are reachable
+          # by agent processes the daemon spawns.
+          PATH = lib.mkForce (lib.concatStringsSep ":" (
+            lib.optionals (cfg.user != "paseo") [
+              "${userHome}/.nix-profile/bin"
+              "${userHome}/.local/state/nix/profile/bin"
+            ]
+            ++ [
+              "/etc/profiles/per-user/${cfg.user}/bin"
+              "/run/current-system/sw/bin"
+              "/run/wrappers/bin"
+              "/nix/var/nix/profiles/default/bin"
+            ]
+          ));
+        }
+      ) // lib.optionalAttrs (cfg.hostnames == true) {
         PASEO_HOSTNAMES = "true";
       } // lib.optionalAttrs (lib.isList cfg.hostnames && cfg.hostnames != [ ]) {
         PASEO_HOSTNAMES = lib.concatStringsSep "," cfg.hostnames;

nix/npm-deps.hash

@@ -1 +1 @@
-sha256-LczD9EmK6LuaJuZQu1v/q8zBE92LVynRR85dp6IdfCo=
+sha256-SRax+Frqf0OhDhfWICSlhOnHBGsoHiXQc6P+zo5VjN8=

nix/package.nix

@@ -88,47 +88,25 @@ buildNpmPackage rec {
   installPhase = ''
     runHook preInstall
 
+    # Compute the daemon's runtime closure by static module-graph tracing
+    # (@vercel/nft from supervisor-entrypoint.js, cli/dist/index.js, and the
+    # forked terminal-worker-process.js) plus an explicit list of non-JS
+    # assets read at runtime. The trace script is the single source of
+    # truth for what the daemon needs at $out — auditable in plain JS, no
+    # npm hoisting / .bin / workspace-symlink footguns.
     mkdir -p $out/lib/paseo
+    node scripts/trace-daemon.mjs > daemon-files.txt
 
-    # Copy root package metadata
+    while IFS= read -r path; do
+      [ -z "$path" ] && continue
+      mkdir -p "$out/lib/paseo/$(dirname "$path")"
+      cp -a "$path" "$out/lib/paseo/$path"
+    done < daemon-files.txt
+
+    # Root package.json lets node resolve the workspace layout when the
+    # CLI/server bin starts from $out.
     cp package.json $out/lib/paseo/
 
-    # Copy node_modules (preserving workspace symlinks)
-    cp -a node_modules $out/lib/paseo/
-
-    # Auto-detect which @getpaseo/* packages were built by build:daemon
-    # (they'll have a dist/ directory). Copy those and remove the rest.
-    for link in $out/lib/paseo/node_modules/@getpaseo/*; do
-      name=$(basename "$link")
-      if [ -d "packages/$name/dist" ]; then
-        mkdir -p "$out/lib/paseo/packages/$name"
-        cp "packages/$name/package.json" "$out/lib/paseo/packages/$name/"
-        cp -a "packages/$name/dist" "$out/lib/paseo/packages/$name/"
-        if [ -d "packages/$name/node_modules" ]; then
-          cp -a "packages/$name/node_modules" "$out/lib/paseo/packages/$name/"
-        fi
-      else
-        rm -f "$link"
-      fi
-    done
-
-    # Copy CLI bin entry
-    mkdir -p $out/lib/paseo/packages/cli/bin
-    cp packages/cli/bin/paseo $out/lib/paseo/packages/cli/bin/
-
-    # Copy extra server files referenced at runtime
-    for f in agent-prompt.md .env.example; do
-      if [ -f packages/server/$f ]; then
-        cp packages/server/$f $out/lib/paseo/packages/server/
-      fi
-    done
-
-    # Copy server scripts (including supervisor-entrypoint) needed by CLI
-    if [ -d packages/server/dist/scripts ]; then
-      mkdir -p $out/lib/paseo/packages/server/dist/scripts
-      cp -a packages/server/dist/scripts/* $out/lib/paseo/packages/server/dist/scripts/
-    fi
-
     # Create wrapper for the server entry point (for systemd / direct use)
     mkdir -p $out/bin
     makeWrapper ${nodejs}/bin/node $out/bin/paseo-server \

package.json

@@ -1,6 +1,6 @@
 {
   "name": "paseo",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "private": true,
   "description": "Paseo: voice-controlled development environment with OpenAI Realtime API",
   "keywords": [
@@ -93,6 +93,7 @@
   "devDependencies": {
     "@types/ws": "^8.5.14",
     "@typescript/native-preview": "7.0.0-dev.20260423.1",
+    "@vercel/nft": "^1.5.0",
     "concurrently": "^9.2.1",
     "cross-env": "^10.1.0",
     "get-port-cli": "^3.0.0",

packages/app/.eas/workflows/release-mobile.yml

@@ -41,7 +41,7 @@ jobs:
 
   submit_ios_for_review:
     name: Submit iOS for App Store review
-    needs: [submit_ios]
+    needs: [build_ios, submit_ios]
     environment: production
     runs_on: macos-medium
     steps:
@@ -49,4 +49,7 @@ jobs:
       - name: Install fastlane
         run: bundle install
       - name: Submit for review
-        run: bundle exec fastlane ios submit_review
+        run: |
+          export APP_VERSION="${{ needs.build_ios.outputs.app_version }}"
+          export APP_BUILD_VERSION="${{ needs.build_ios.outputs.app_build_version }}"
+          bundle exec fastlane ios submit_review

packages/app/.eas/workflows/resubmit-ios-review.yml

@@ -6,7 +6,16 @@ name: Resubmit iOS for App Store review
 # TestFlight build, without rebuilding or re-uploading.
 
 on:
-  workflow_dispatch: {}
+  workflow_dispatch:
+    inputs:
+      app_version:
+        type: string
+        required: false
+        description: "Marketing version to resubmit, e.g. 0.1.76. Leave empty to target the most recently uploaded iOS build."
+      app_build_version:
+        type: string
+        required: false
+        description: "CFBundleVersion to resubmit, e.g. 2. Only used when app_version is set."
 
 jobs:
   submit_ios_for_review:
@@ -18,4 +27,7 @@ jobs:
       - name: Install fastlane
         run: bundle install
       - name: Submit for review
-        run: bundle exec fastlane ios submit_review
+        run: |
+          export APP_VERSION="${{ inputs.app_version }}"
+          export APP_BUILD_VERSION="${{ inputs.app_build_version }}"
+          bundle exec fastlane ios submit_review

packages/app/Gemfile

@@ -1,3 +1,3 @@
 source "https://rubygems.org"
 
-gem "fastlane"
+gem "fastlane", "~> 2.234"

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

@@ -6,6 +6,7 @@ import {
   expectTurnCopyButton,
   expectScrollFollowsNewContent,
 } from "./helpers/agent-stream";
+import { clickNewChat } from "./helpers/launcher";
 import { startRunningMockAgent } from "./helpers/composer";
 
 test.describe("Agent stream UI", () => {
@@ -42,4 +43,23 @@ test.describe("Agent stream UI", () => {
       await repo.cleanup();
     }
   });
+
+  test("shows elapsed timer on first app-created running turn", async ({ page, withWorkspace }) => {
+    test.setTimeout(90_000);
+    const workspace = await withWorkspace({ prefix: "stream-first-app-turn-timer-" });
+    await workspace.navigateTo();
+    await clickNewChat(page);
+    await page.getByText("Model defaults are still loading").waitFor({
+      state: "hidden",
+      timeout: 30_000,
+    });
+    const prompt = "Stream briefly for first app-created turn timer test.";
+    const composer = page.getByRole("textbox", { name: "Message agent..." }).first();
+    await composer.fill(prompt);
+    await page.getByRole("button", { name: "Send message" }).click();
+    await page.getByText(prompt, { exact: true }).first().waitFor({ state: "visible" });
+    await awaitAssistantMessage(page);
+    await expectInlineWorkingIndicator(page);
+    await page.getByTestId("turn-working-elapsed").waitFor({ state: "visible", timeout: 5_000 });
+  });
 });

packages/app/e2e/client-slash-commands.spec.ts

@@ -0,0 +1,205 @@
+import { expect, test, type Page } from "./fixtures";
+import { buildHostWorkspaceRoute } from "@/utils/host-routes";
+import { composerLocator, expectComposerVisible, submitMessage } from "./helpers/composer";
+import { connectTerminalClient, type TerminalPerfDaemonClient } from "./helpers/terminal-perf";
+import { createTempGitRepo } from "./helpers/workspace";
+import {
+  expectSessionRowArchived,
+  expectWorkspaceTabHidden,
+  expectWorkspaceTabVisible,
+  openSessions,
+} from "./helpers/archive-tab";
+
+interface SlashCommandScenario {
+  agent: { id: string };
+  client: TerminalPerfDaemonClient;
+  cwd: string;
+  title: string;
+}
+
+const REPLACEMENT_PROMPT = "Replacement prompt after slash clear.";
+
+function getServerId(): string {
+  const serverId = process.env.E2E_SERVER_ID;
+  if (!serverId) {
+    throw new Error("E2E_SERVER_ID is not set.");
+  }
+  return serverId;
+}
+
+async function withOpenReadyMockAgent(
+  page: Page,
+  input: {
+    title: string;
+    model?: string;
+    modeId?: string;
+  },
+  run: (scenario: SlashCommandScenario) => Promise<void>,
+): Promise<void> {
+  const repo = await createTempGitRepo("client-slash-command-");
+  const client = await connectTerminalClient();
+
+  try {
+    await openProject(client, repo.path);
+    const agent = await createReadyMockAgent(client, {
+      cwd: repo.path,
+      title: input.title,
+      model: input.model,
+      modeId: input.modeId,
+    });
+    await openActiveAgentTab(page, { cwd: repo.path, agentId: agent.id });
+
+    await run({ agent, client, cwd: repo.path, title: input.title });
+  } finally {
+    await client.close();
+    await repo.cleanup();
+  }
+}
+
+async function openProject(client: TerminalPerfDaemonClient, cwd: string): Promise<void> {
+  const opened = await client.openProject(cwd);
+  if (!opened.workspace) {
+    throw new Error(opened.error ?? `Failed to open project ${cwd}`);
+  }
+}
+
+async function createReadyMockAgent(
+  client: TerminalPerfDaemonClient,
+  input: {
+    cwd: string;
+    title: string;
+    model?: string;
+    modeId?: string;
+  },
+): Promise<{ id: string }> {
+  const agent = await client.createAgent({
+    provider: "mock",
+    cwd: input.cwd,
+    title: input.title,
+    modeId: input.modeId ?? "load-test",
+    model: input.model ?? "ten-second-stream",
+    initialPrompt: "Prepare a client slash command test agent.",
+  });
+  return { id: agent.id };
+}
+
+async function openActiveAgentTab(
+  page: Page,
+  input: { cwd: string; agentId: string },
+): Promise<void> {
+  const agentUrl = `${buildHostWorkspaceRoute(
+    getServerId(),
+    input.cwd,
+  )}?open=${encodeURIComponent(`agent:${input.agentId}`)}`;
+  await page.goto(agentUrl);
+  await page.waitForURL(
+    (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
+    { timeout: 60_000 },
+  );
+  await expectWorkspaceTabVisible(page, input.agentId);
+  await expectComposerVisible(page);
+}
+
+async function runClientSlashCommand(page: Page, command: "/quit" | "/clear"): Promise<void> {
+  const input = composerLocator(page);
+  await expect(input).toBeEditable({ timeout: 30_000 });
+  await input.fill(command);
+  await expect(input).toHaveValue(command);
+  await input.press("Enter");
+}
+
+async function selectClientSlashCommand(page: Page, query: string, label: string): Promise<void> {
+  const input = composerLocator(page);
+  await expect(input).toBeEditable({ timeout: 30_000 });
+  await input.fill(query);
+  await expect(page.getByText(label, { exact: true }).first()).toBeVisible({ timeout: 30_000 });
+  await input.press("Enter");
+}
+
+async function expectAgentArchivedInSessions(page: Page, title: string): Promise<void> {
+  await openSessions(page);
+  await expectSessionRowArchived(page, title);
+}
+
+async function expectReplacementDraftMatchesPreviousSetup(page: Page): Promise<void> {
+  await expectComposerVisible(page);
+  await expect(
+    page.getByRole("button", { name: "Select model (Ten second stream)" }),
+  ).toBeVisible();
+  await expect(page.getByRole("button", { name: "Select agent mode (load-test)" })).toBeVisible();
+}
+
+async function createAgentFromReplacementDraft(page: Page): Promise<void> {
+  await submitMessage(page, REPLACEMENT_PROMPT);
+}
+
+async function waitForReplacementAgentId(page: Page, oldAgentId: string): Promise<string> {
+  let newAgentId: string | null = null;
+  await expect
+    .poll(
+      async () => {
+        const ids = await page
+          .locator('[data-testid^="workspace-tab-agent_"]')
+          .evaluateAll((nodes) =>
+            nodes.flatMap((node) => {
+              if (!(node instanceof HTMLElement)) {
+                return [];
+              }
+              const testId = node.getAttribute("data-testid") ?? "";
+              if (!testId.startsWith("workspace-tab-agent_")) {
+                return [];
+              }
+              if (node.offsetParent === null) {
+                return [];
+              }
+              return [testId.slice("workspace-tab-agent_".length)];
+            }),
+          );
+        newAgentId = ids.find((id) => id !== oldAgentId) ?? null;
+        return newAgentId;
+      },
+      { timeout: 30_000 },
+    )
+    .not.toBeNull();
+  if (!newAgentId) {
+    throw new Error("Replacement agent was not created.");
+  }
+  return newAgentId;
+}
+
+test.describe("Client slash commands", () => {
+  test("slash quit archives the active agent and removes its tab", async ({ page }) => {
+    await withOpenReadyMockAgent(page, { title: "Slash quit e2e" }, async ({ agent, title }) => {
+      await runClientSlashCommand(page, "/quit");
+      await expectWorkspaceTabHidden(page, agent.id);
+      await expectAgentArchivedInSessions(page, title);
+    });
+  });
+
+  test("slash quit selected from autocomplete archives immediately", async ({ page }) => {
+    await withOpenReadyMockAgent(
+      page,
+      { title: "Slash quit autocomplete e2e" },
+      async ({ agent, title }) => {
+        await selectClientSlashCommand(page, "/qu", "/quit");
+        await expectWorkspaceTabHidden(page, agent.id);
+        await expectAgentArchivedInSessions(page, title);
+      },
+    );
+  });
+
+  test("slash clear replaces the active agent with a matching draft", async ({ page }) => {
+    await withOpenReadyMockAgent(
+      page,
+      { title: "Slash clear e2e", model: "ten-second-stream", modeId: "load-test" },
+      async ({ agent, title }) => {
+        await runClientSlashCommand(page, "/clear");
+        await expectWorkspaceTabHidden(page, agent.id);
+        await expectReplacementDraftMatchesPreviousSetup(page);
+        await createAgentFromReplacementDraft(page);
+        await waitForReplacementAgentId(page, agent.id);
+        await expectAgentArchivedInSessions(page, title);
+      },
+    );
+  });
+});

packages/app/e2e/helpers/sidebar.ts

@@ -24,9 +24,10 @@ export async function openMobileAgentSidebar(page: Page): Promise<void> {
   await page.getByRole("button", { name: "Open menu" }).click();
 }
 
-// force=true: the overlay covers the button when the mobile sidebar is open.
 export async function closeMobileAgentSidebar(page: Page): Promise<void> {
-  await page.getByRole("button", { name: "Close menu" }).click({ force: true });
+  const closeButton = page.getByTestId("sidebar-close");
+  await expect(closeButton).toBeInViewport({ timeout: 5_000 });
+  await closeButton.click({ force: true });
 }
 
 // The mobile sidebar panel animates via translateX; toBeInViewport reflects the rendered position.

packages/app/e2e/helpers/terminal-perf.ts

@@ -29,6 +29,11 @@ export interface TerminalPerfDaemonClient {
     featureValues?: Record<string, unknown>;
     initialPrompt?: string;
   }): Promise<{ id: string; status: string }>;
+  waitForAgentUpsert(
+    agentId: string,
+    predicate: (snapshot: { status: string }) => boolean,
+    timeout?: number,
+  ): Promise<{ status: string }>;
   sendAgentMessage(agentId: string, text: string): Promise<void>;
   subscribeTerminal(
     terminalId: string,

packages/app/fastlane/Fastfile

@@ -11,11 +11,6 @@ platform :ios do
       key_filepath: ENV.fetch("ASC_KEY_P8"),
     )
 
-    build_number = latest_testflight_build_number(
-      api_key: api_key,
-      app_identifier: APP_IDENTIFIER,
-    )
-
     require "spaceship"
     Spaceship::ConnectAPI.token = Spaceship::ConnectAPI::Token.create(
       key_id: ENV.fetch("ASC_KEY_ID"),
@@ -25,30 +20,58 @@ platform :ios do
     app = Spaceship::ConnectAPI::App.find(APP_IDENTIFIER)
     UI.user_error!("Could not find app #{APP_IDENTIFIER} on App Store Connect") if app.nil?
 
+    # The release workflow forwards the marketing version and CFBundleVersion of
+    # the binary it just built. Use them to identify the exact build, since
+    # CFBundleVersion is not unique across marketing versions in this project
+    # (the production profile resets it per app_version). The resubmit workflow
+    # leaves these unset and falls back to "most recently uploaded iOS build".
+    target_version = ENV["APP_VERSION"].to_s.strip
+    target_build = ENV["APP_BUILD_VERSION"].to_s.strip
+    target_version = nil if target_version.empty?
+    target_build = nil if target_build.empty?
+
+    if target_version
+      UI.message("Targeting App Store version #{target_version}#{target_build ? " build #{target_build}" : ""} from workflow input")
+    else
+      UI.message("No APP_VERSION provided; selecting the most recently uploaded iOS build")
+    end
+
     valid_build = nil
     deadline = Time.now + (30 * 60)
     loop do
       builds = Spaceship::ConnectAPI::Build.all(
         app_id: app.id,
-        build_number: build_number.to_s,
-      )
-      build = builds.find { |b| b.pre_release_version&.platform == "IOS" }
-      state = build&.processing_state
-      UI.message("Build #{build_number} processing state: #{state || 'unknown'}")
+        sort: "-uploadedDate",
+        limit: 100,
+      ).select { |b| b.pre_release_version&.platform == "IOS" }
+      builds = builds.select { |b| b.pre_release_version&.version == target_version } if target_version
+      builds = builds.select { |b| b.version == target_build } if target_build
+
+      build = builds.first
+      if build.nil?
+        UI.user_error!("Timed out waiting for build to appear on App Store Connect.") if Time.now > deadline
+        UI.message("No matching iOS build visible on App Store Connect yet; waiting...")
+        sleep(30)
+        next
+      end
+
+      state = build.processing_state
+      UI.message("Build #{build.pre_release_version.version} (#{build.version}) processing state: #{state || 'unknown'}")
       if state == "VALID"
         valid_build = build
         break
       end
       if state == "INVALID" || state == "FAILED"
-        UI.user_error!("Build #{build_number} failed App Store processing (state: #{state}).")
+        UI.user_error!("Build #{build.version} failed App Store processing (state: #{state}).")
       end
       if Time.now > deadline
-        UI.user_error!("Timed out waiting for build #{build_number} to finish processing on App Store Connect.")
+        UI.user_error!("Timed out waiting for build #{build.version} to finish processing on App Store Connect.")
       end
       sleep(30)
     end
 
     app_version = valid_build.pre_release_version.version
+    build_number = valid_build.version
     UI.message("Submitting build #{build_number} as App Store version #{app_version} for review")
 
     # Ensure an editable App Store version exists for this marketing version.

packages/app/modules/paseo-hardware-keyboard/expo-module.config.json

@@ -0,0 +1,7 @@
+{
+  "platforms": ["ios"],
+  "ios": {
+    "modules": ["PaseoHardwareKeyboardModule"],
+    "reactDelegateHandlers": ["PaseoHardwareKeyboardReactDelegateHandler"]
+  }
+}

packages/app/modules/paseo-hardware-keyboard/ios/PaseoHardwareKeyboard.podspec

@@ -0,0 +1,24 @@
+require 'json'
+
+Pod::Spec.new do |s|
+  s.name           = 'PaseoHardwareKeyboard'
+  s.version        = '0.1.0'
+  s.summary        = 'Hardware keyboard shortcuts for Paseo'
+  s.description    = 'Hardware keyboard shortcuts for Paseo'
+  s.license        = 'AGPL-3.0-or-later'
+  s.author         = 'Paseo'
+  s.homepage       = 'https://paseo.sh'
+  s.platforms      = { :ios => '13.4' }
+  s.swift_version  = '5.4'
+  s.source         = { :path => '.' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  s.source_files = "**/*.{h,m,swift}"
+end

packages/app/modules/paseo-hardware-keyboard/ios/PaseoHardwareKeyboardModule.swift

@@ -0,0 +1,99 @@
+import ExpoModulesCore
+import UIKit
+
+private let hardwareSubmitEventName = "onHardwareKeyboardSubmit"
+
+private weak var activeModule: PaseoHardwareKeyboardModule?
+private var isHardwareSubmitEnabled = false
+
+@objc
+public class PaseoHardwareKeyboardReactDelegateHandler: ExpoReactDelegateHandler {
+  public override func createRootViewController() -> UIViewController? {
+    return PaseoHardwareKeyboardRootViewController()
+  }
+}
+
+public class PaseoHardwareKeyboardModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("PaseoHardwareKeyboard")
+
+    Events(hardwareSubmitEventName)
+
+    OnCreate {
+      activeModule = self
+    }
+
+    Function("setHardwareKeyboardSubmitEnabled") { (enabled: Bool) in
+      DispatchQueue.main.async {
+        isHardwareSubmitEnabled = enabled
+      }
+    }
+
+    OnDestroy {
+      if activeModule === self {
+        activeModule = nil
+      }
+      isHardwareSubmitEnabled = false
+    }
+  }
+
+  fileprivate func emitHardwareKeyboardSubmit() {
+    sendEvent(hardwareSubmitEventName, [:])
+  }
+}
+
+private final class PaseoHardwareKeyboardRootViewController: UIViewController {
+  override var keyCommands: [UIKeyCommand]? {
+    guard isHardwareSubmitEnabled && UIDevice.current.userInterfaceIdiom == .pad else {
+      return super.keyCommands
+    }
+
+    let command = UIKeyCommand(
+      input: "\r",
+      modifierFlags: [],
+      action: #selector(handleHardwareKeyboardSubmit(_:))
+    )
+    if #available(iOS 15.0, *) {
+      command.wantsPriorityOverSystemBehavior = true
+    }
+    return (super.keyCommands ?? []) + [command]
+  }
+
+  @objc
+  private func handleHardwareKeyboardSubmit(_ sender: UIKeyCommand) {
+    guard canSubmitCurrentTextInput() else {
+      return
+    }
+    activeModule?.emitHardwareKeyboardSubmit()
+  }
+
+  private func canSubmitCurrentTextInput() -> Bool {
+    guard let responder = UIResponder.paseoCurrentFirstResponder else {
+      return false
+    }
+    guard let textInput = responder as? UITextInput else {
+      return false
+    }
+    return textInput.markedTextRange == nil
+  }
+}
+
+private extension UIResponder {
+  private static weak var currentFirstResponder: UIResponder?
+
+  static var paseoCurrentFirstResponder: UIResponder? {
+    currentFirstResponder = nil
+    UIApplication.shared.sendAction(
+      #selector(captureCurrentFirstResponder(_:)),
+      to: nil,
+      from: nil,
+      for: nil
+    )
+    return currentFirstResponder
+  }
+
+  @objc
+  private func captureCurrentFirstResponder(_ sender: Any?) {
+    UIResponder.currentFirstResponder = self
+  }
+}

packages/app/modules/paseo-hardware-keyboard/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "paseo-hardware-keyboard",
+  "version": "0.1.0",
+  "private": true
+}

packages/app/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@getpaseo/app",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "private": true,
   "main": "index.ts",
   "scripts": {
-    "start": "APP_VARIANT=development expo start",
+    "start": "cross-env APP_VARIANT=development expo start",
     "reset-project": "node ./scripts/reset-project.js",
     "build:workspace-deps": "npm run build --workspace=@getpaseo/highlight && npm run build --workspace=@getpaseo/expo-two-way-audio",
     "eas-build-post-install": "npm run build:workspace-deps",
     "android": "npm run android:development",
-    "android:development": "APP_VARIANT=development expo prebuild --platform android --non-interactive && APP_VARIANT=development expo run:android --variant=debug",
-    "android:production": "APP_VARIANT=production expo prebuild --platform android --non-interactive && APP_VARIANT=production expo run:android --variant=release",
+    "android:development": "cross-env APP_VARIANT=development expo prebuild --platform android --non-interactive && cross-env APP_VARIANT=development expo run:android --variant=debug",
+    "android:production": "cross-env APP_VARIANT=production expo prebuild --platform android --non-interactive && cross-env APP_VARIANT=production expo run:android --variant=release",
     "android:release": "npm run android:production",
     "android:clear": "node -e \"require('node:fs').rmSync('android', { recursive: true, force: true })\"",
     "ios": "expo run:ios",

packages/app/src/app/_layout.tsx

@@ -56,6 +56,7 @@ import { useActiveWorktreeNewAction } from "@/hooks/use-active-worktree-new-acti
 import { useFaviconStatus } from "@/hooks/use-favicon-status";
 import { useKeyboardShortcuts } from "@/hooks/use-keyboard-shortcuts";
 import { useLatchedBoolean } from "@/hooks/use-latched-boolean";
+import { useCompactWebViewportZoomLock } from "@/hooks/use-compact-web-viewport-zoom-lock";
 import { useOpenProject } from "@/hooks/use-open-project";
 import { useAppSettings } from "@/hooks/use-settings";
 import { useStableEvent } from "@/hooks/use-stable-event";
@@ -375,6 +376,8 @@ function QueryProvider({ children }: { children: ReactNode }) {
 
 const rowStyle = { flex: 1, flexDirection: "row" } as const;
 const flexStyle = { flex: 1 } as const;
+const MOBILE_WEB_EDGE_SWIPE_WIDTH = 32;
+const MOBILE_WEB_GESTURE_TOUCH_ACTION = isWeb ? "auto" : "pan-y";
 
 interface AppContainerProps {
   children: ReactNode;
@@ -406,6 +409,7 @@ function AppContainer({
   }, [settings.theme, updateSettings]);
 
   const isCompactLayout = useIsCompactFormFactor();
+  useCompactWebViewportZoomLock(isCompactLayout);
   const chromeEnabled = chromeEnabledOverride ?? daemons.length > 0;
   const pathname = usePathname();
   const activeServerId = useMemo(
@@ -498,6 +502,7 @@ function MobileGestureWrapper({
     openGestureRef,
   } = useSidebarAnimation();
   const touchStartX = useSharedValue(0);
+  const touchStartY = useSharedValue(0);
   const openGestureEnabled = chromeEnabled && mobileView === "agent";
 
   const handleGestureOpen = useCallback(() => {
@@ -516,6 +521,7 @@ function MobileGestureWrapper({
           const touch = event.changedTouches[0];
           if (touch) {
             touchStartX.value = touch.absoluteX;
+            touchStartY.value = touch.absoluteY;
           }
         })
         .onTouchesMove((event, stateManager) => {
@@ -523,13 +529,31 @@ function MobileGestureWrapper({
           if (!touch || event.numberOfTouches !== 1) return;
 
           const deltaX = touch.absoluteX - touchStartX.value;
+          const deltaY = touch.absoluteY - touchStartY.value;
+          const absDeltaX = Math.abs(deltaX);
+          const absDeltaY = Math.abs(deltaY);
 
           if (horizontalScroll?.isAnyScrolledRight.value) {
             stateManager.fail();
             return;
           }
 
-          if (deltaX > 15) {
+          if (isWeb && touchStartX.value > MOBILE_WEB_EDGE_SWIPE_WIDTH) {
+            stateManager.fail();
+            return;
+          }
+
+          if (deltaX <= -10) {
+            stateManager.fail();
+            return;
+          }
+
+          if (absDeltaY > 10 && absDeltaY > absDeltaX) {
+            stateManager.fail();
+            return;
+          }
+
+          if (deltaX > 15 && absDeltaX > absDeltaY) {
             stateManager.activate();
           }
         })
@@ -571,11 +595,12 @@ function MobileGestureWrapper({
       openGestureRef,
       horizontalScroll?.isAnyScrolledRight,
       touchStartX,
+      touchStartY,
     ],
   );
 
   return (
-    <GestureDetector gesture={openGesture} touchAction="pan-y">
+    <GestureDetector gesture={openGesture} touchAction={MOBILE_WEB_GESTURE_TOUCH_ACTION}>
       {children}
     </GestureDetector>
   );

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

@@ -2,10 +2,16 @@ import { useLocalSearchParams } from "expo-router";
 import { NewWorkspaceScreen } from "@/screens/new-workspace-screen";
 
 export default function HostNewWorkspaceRoute() {
-  const params = useLocalSearchParams<{ serverId?: string; dir?: string; name?: string }>();
+  const params = useLocalSearchParams<{
+    serverId?: string;
+    dir?: string;
+    name?: string;
+    projectId?: string;
+  }>();
   const serverId = typeof params.serverId === "string" ? params.serverId : "";
   const sourceDirectory = typeof params.dir === "string" ? params.dir : "";
   const displayName = typeof params.name === "string" ? params.name : undefined;
+  const projectId = typeof params.projectId === "string" ? params.projectId : undefined;
 
   if (!sourceDirectory) {
     return null;
@@ -16,6 +22,7 @@ export default function HostNewWorkspaceRoute() {
       serverId={serverId}
       sourceDirectory={sourceDirectory}
       displayName={displayName}
+      projectId={projectId}
     />
   );
 }

packages/app/src/assistant-file-links/index.ts

@@ -0,0 +1,13 @@
+export {
+  AssistantInlineCodePathLink,
+  AssistantInlinePathLink,
+  AssistantMarkdownCodeLink,
+  AssistantMarkdownLink,
+} from "./link";
+export {
+  classifyAssistantFileLink,
+  normalizeInlinePathTarget,
+  type InlinePathTarget,
+} from "./parse";
+export type { AssistantFileLinkSource } from "./resolver";
+export { useAssistantFileLinkResolver } from "./use-resolver";

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

@@ -0,0 +1,346 @@
+import {
+  useCallback,
+  useMemo,
+  useState,
+  type CSSProperties,
+  type ReactNode,
+  type MouseEvent,
+} from "react";
+import {
+  Pressable,
+  Text,
+  View,
+  type StyleProp,
+  type TextStyle,
+  type ViewStyle,
+} from "react-native";
+import { StyleSheet } from "react-native-unistyles";
+import { isNative, isWeb } from "@/constants/platform";
+import type { OpenFileDisposition } from "@/workspace/file-open";
+import { Shortcut } from "@/components/ui/shortcut";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip";
+import { classifyAssistantFileLink, type InlinePathTarget } from "./parse";
+import type { AssistantFileLinkSource } from "./resolver";
+
+interface AssistantInlinePathLinkProps {
+  content: string;
+  parsed: InlinePathTarget;
+  onPress: (target: InlinePathTarget, disposition: OpenFileDisposition) => void;
+  workspaceRoot?: string;
+  style: StyleProp<TextStyle>;
+}
+
+export function AssistantInlinePathLink({
+  content,
+  parsed,
+  onPress,
+  workspaceRoot,
+  style,
+}: AssistantInlinePathLinkProps) {
+  const handlePress = useCallback(() => onPress(parsed, "main"), [onPress, parsed]);
+  const handleAnchorClickCapture = useCallback(
+    (event: MouseEvent<HTMLAnchorElement>) => {
+      event.preventDefault();
+      if (!isModifiedOpenEvent(event)) {
+        return;
+      }
+      event.stopPropagation();
+      onPress(parsed, "side");
+    },
+    [onPress, parsed],
+  );
+
+  if (!isNative) {
+    return (
+      <FileLinkHoverTooltip filePath={formatInlinePathTargetForTooltip(parsed, workspaceRoot)}>
+        <a
+          href={parsed.path}
+          onClickCapture={handleAnchorClickCapture}
+          onAuxClickCapture={preventAnchorNavigation}
+          style={LINK_ANCHOR_STYLE}
+        >
+          <Text onPress={handlePress} selectable={isWeb ? undefined : false} style={style}>
+            {content}
+          </Text>
+        </a>
+      </FileLinkHoverTooltip>
+    );
+  }
+
+  return (
+    <Text onPress={handlePress} selectable={isWeb ? undefined : false} style={style}>
+      {content}
+    </Text>
+  );
+}
+
+interface AssistantMarkdownLinkProps {
+  source: AssistantFileLinkSource;
+  style: StyleProp<TextStyle>;
+  onPress: (source: AssistantFileLinkSource, disposition: OpenFileDisposition) => void;
+  onPrefetch: (source: AssistantFileLinkSource) => void;
+  workspaceRoot?: string;
+  children: ReactNode;
+}
+
+export function AssistantMarkdownLink({
+  source,
+  style,
+  onPress,
+  onPrefetch,
+  workspaceRoot,
+  children,
+}: AssistantMarkdownLinkProps) {
+  const [hovered, setHovered] = useState(false);
+  const href = source.href;
+  const handlePress = useCallback(() => onPress(source, "main"), [onPress, source]);
+  const handleAnchorClickCapture = useCallback(
+    (event: MouseEvent<HTMLAnchorElement>) => {
+      event.preventDefault();
+      if (!isModifiedOpenEvent(event)) {
+        return;
+      }
+      event.stopPropagation();
+      onPress(source, "side");
+    },
+    [onPress, source],
+  );
+  const handlePrefetch = useCallback(() => onPrefetch(source), [onPrefetch, source]);
+  const handleHoverIn = useCallback(() => {
+    setHovered(true);
+    handlePrefetch();
+  }, [handlePrefetch]);
+  const handleHoverOut = useCallback(() => setHovered(false), []);
+  const hoveredTextStyle = useMemo<StyleProp<TextStyle>>(
+    () => [style, hovered && { textDecorationLine: "underline" as const }],
+    [style, hovered],
+  );
+  const tooltipFilePath = useMemo(
+    () => getMarkdownLinkTooltipFilePath(source.href, workspaceRoot),
+    [source.href, workspaceRoot],
+  );
+  if (isNative) {
+    return (
+      <Text accessibilityRole="link" onPress={handlePress} style={style}>
+        {children}
+      </Text>
+    );
+  }
+
+  const anchor = (
+    <a
+      href={href}
+      onClickCapture={handleAnchorClickCapture}
+      onAuxClickCapture={preventAnchorNavigation}
+      style={LINK_ANCHOR_STYLE}
+    >
+      <Pressable
+        accessibilityRole="link"
+        onPress={handlePress}
+        onFocus={handlePrefetch}
+        onHoverIn={handleHoverIn}
+        onHoverOut={handleHoverOut}
+      >
+        <Text style={hoveredTextStyle}>{children}</Text>
+      </Pressable>
+    </a>
+  );
+
+  if (tooltipFilePath) {
+    return <FileLinkHoverTooltip filePath={tooltipFilePath}>{anchor}</FileLinkHoverTooltip>;
+  }
+  return anchor;
+}
+
+interface AssistantMarkdownCodeLinkProps {
+  source: AssistantFileLinkSource;
+  inheritedStyles: TextStyle;
+  codeInlineStyle: TextStyle;
+  linkStyle: TextStyle;
+  onPress: (source: AssistantFileLinkSource, disposition: OpenFileDisposition) => void;
+  onPrefetch: (source: AssistantFileLinkSource) => void;
+  workspaceRoot?: string;
+  children: ReactNode;
+}
+
+export function AssistantMarkdownCodeLink({
+  source,
+  inheritedStyles,
+  codeInlineStyle,
+  linkStyle,
+  onPress,
+  onPrefetch,
+  workspaceRoot,
+  children,
+}: AssistantMarkdownCodeLinkProps) {
+  const style = useMemo(
+    () => [inheritedStyles, codeInlineStyle, linkStyle],
+    [inheritedStyles, codeInlineStyle, linkStyle],
+  );
+  return (
+    <AssistantMarkdownLink
+      source={source}
+      style={style}
+      onPress={onPress}
+      onPrefetch={onPrefetch}
+      workspaceRoot={workspaceRoot}
+    >
+      {children}
+    </AssistantMarkdownLink>
+  );
+}
+
+interface AssistantInlineCodePathLinkProps {
+  content: string;
+  inheritedStyles: TextStyle;
+  codeInlineStyle: TextStyle;
+  linkStyle: TextStyle;
+  onPress: (source: AssistantFileLinkSource, disposition: OpenFileDisposition) => void;
+  onPrefetch: (source: AssistantFileLinkSource) => void;
+  workspaceRoot?: string;
+}
+
+export function AssistantInlineCodePathLink({
+  content,
+  inheritedStyles,
+  codeInlineStyle,
+  linkStyle,
+  onPress,
+  onPrefetch,
+  workspaceRoot,
+}: AssistantInlineCodePathLinkProps) {
+  const source = useMemo<AssistantFileLinkSource>(
+    () => ({
+      href: content,
+      text: content,
+      sourceType: "inline-code",
+    }),
+    [content],
+  );
+
+  return (
+    <AssistantMarkdownCodeLink
+      source={source}
+      inheritedStyles={inheritedStyles}
+      codeInlineStyle={codeInlineStyle}
+      linkStyle={linkStyle}
+      onPress={onPress}
+      onPrefetch={onPrefetch}
+      workspaceRoot={workspaceRoot}
+    >
+      {content}
+    </AssistantMarkdownCodeLink>
+  );
+}
+
+function getMarkdownLinkTooltipFilePath(
+  href: string,
+  workspaceRoot: string | undefined,
+): string | null {
+  const classification = classifyAssistantFileLink(href, { workspaceRoot });
+  if (classification?.kind !== "directFile") {
+    return null;
+  }
+  return formatInlinePathTargetForTooltip(classification.target, workspaceRoot);
+}
+
+function formatInlinePathTargetForTooltip(
+  target: InlinePathTarget,
+  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;
+}
+
+const FILE_LINK_TOOLTIP_TRIGGER_STYLE: ViewStyle = {
+  // RN doesn't type "inline-flex" but RN-web honors it at runtime, which keeps
+  // the tooltip wrapper from breaking inline link flow.
+  display: "inline-flex" as ViewStyle["display"],
+};
+
+const FILE_LINK_TOOLTIP_MOD_KEYS = ["mod"];
+
+function FileLinkHoverTooltip({ filePath, children }: { filePath: string; children: ReactNode }) {
+  if (!isWeb) {
+    return children;
+  }
+  return (
+    <Tooltip delayDuration={400}>
+      <TooltipTrigger asChild>
+        <View style={FILE_LINK_TOOLTIP_TRIGGER_STYLE}>{children}</View>
+      </TooltipTrigger>
+      <TooltipContent side="top" align="start" maxWidth={520}>
+        <View style={styles.tooltipBody}>
+          <Text selectable={false} style={styles.tooltipPath}>
+            {filePath}
+          </Text>
+          <View style={styles.tooltipHintRow}>
+            <Shortcut keys={FILE_LINK_TOOLTIP_MOD_KEYS} />
+            <Text selectable={false} style={styles.tooltipHintText}>
+              click for side pane
+            </Text>
+          </View>
+        </View>
+      </TooltipContent>
+    </Tooltip>
+  );
+}
+
+const LINK_ANCHOR_STYLE: CSSProperties = {
+  display: "contents",
+  color: "inherit",
+  textDecoration: "none",
+};
+
+function preventAnchorNavigation(event: MouseEvent<HTMLAnchorElement>): void {
+  event.preventDefault();
+}
+
+function isModifiedOpenEvent(event: MouseEvent<HTMLElement>): boolean {
+  return event.metaKey || event.ctrlKey;
+}
+
+const styles = StyleSheet.create((theme) => ({
+  tooltipBody: {
+    gap: theme.spacing[1],
+  },
+  tooltipPath: {
+    color: theme.colors.foreground,
+    fontSize: theme.fontSize.xs,
+    fontWeight: theme.fontWeight.normal,
+  },
+  tooltipHintRow: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.spacing[1],
+  },
+  tooltipHintText: {
+    color: theme.colors.foregroundMuted,
+    fontSize: theme.fontSize.xs,
+    fontWeight: theme.fontWeight.normal,
+  },
+}));

packages/app/src/assistant-file-links/parse.test.ts

@@ -1,10 +1,11 @@
 import { describe, expect, it } from "vitest";
 import {
+  classifyAssistantFileLink,
   normalizeInlinePathTarget,
   parseAssistantFileLink,
   parseFileProtocolUrl,
   parseInlinePathToken,
-} from "./inline-path";
+} from "./parse";
 
 describe("parseInlinePathToken", () => {
   it("returns null for plain paths without a line number", () => {
@@ -30,6 +31,33 @@ describe("parseInlinePathToken", () => {
     });
   });
 
+  it("parses filename:line:column as a line target", () => {
+    expect(parseInlinePathToken("src/app.ts:12:4")).toEqual({
+      raw: "src/app.ts:12:4",
+      path: "src/app.ts",
+      lineStart: 12,
+      lineEnd: undefined,
+    });
+  });
+
+  it("parses filename(line,column) as a line target", () => {
+    expect(parseInlinePathToken("src/app.ts(12,4)")).toEqual({
+      raw: "src/app.ts(12,4)",
+      path: "src/app.ts",
+      lineStart: 12,
+      lineEnd: undefined,
+    });
+  });
+
+  it("parses filename lines lineStart-lineEnd", () => {
+    expect(parseInlinePathToken("src/app.ts lines 12-20")).toEqual({
+      raw: "src/app.ts lines 12-20",
+      path: "src/app.ts",
+      lineStart: 12,
+      lineEnd: 20,
+    });
+  });
+
   it("rejects range-only :line tokens", () => {
     expect(parseInlinePathToken(":12")).toBeNull();
     expect(parseInlinePathToken(":12-20")).toBeNull();
@@ -46,6 +74,15 @@ describe("parseFileProtocolUrl", () => {
     });
   });
 
+  it("parses file URLs with line-column fragments", () => {
+    expect(parseFileProtocolUrl("file:///Users/test/project/src/app.tsx#L81C5-L83C2")).toEqual({
+      raw: "file:///Users/test/project/src/app.tsx#L81C5-L83C2",
+      path: "/Users/test/project/src/app.tsx",
+      lineStart: 81,
+      lineEnd: 83,
+    });
+  });
+
   it("parses file URLs without line fragments", () => {
     expect(parseFileProtocolUrl("file:///Users/test/project/src/app.tsx")).toEqual({
       raw: "file:///Users/test/project/src/app.tsx",
@@ -70,7 +107,170 @@ describe("parseFileProtocolUrl", () => {
   });
 });
 
+describe("classifyAssistantFileLink", () => {
+  it("keeps explicit external URLs out of file parsing", () => {
+    expect(
+      classifyAssistantFileLink("http://dumm.md", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      kind: "external",
+      raw: "http://dumm.md",
+    });
+    expect(classifyAssistantFileLink("mailto:test@example.com")).toEqual({
+      kind: "external",
+      raw: "mailto:test@example.com",
+    });
+  });
+
+  it("classifies bare workspace candidates separately from direct relative files", () => {
+    expect(
+      classifyAssistantFileLink("dumm.md", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      kind: "ambiguousFileCandidate",
+      target: {
+        raw: "dumm.md",
+        path: "/Users/test/project/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+    });
+
+    expect(
+      classifyAssistantFileLink("message-renderer.tsx", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      kind: "ambiguousFileCandidate",
+      target: {
+        raw: "message-renderer.tsx",
+        path: "/Users/test/project/message-renderer.tsx",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+    });
+
+    expect(
+      classifyAssistantFileLink("src/components/message.tsx#L33", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      kind: "directFile",
+      target: {
+        raw: "src/components/message.tsx#L33",
+        path: "/Users/test/project/src/components/message.tsx",
+        lineStart: 33,
+        lineEnd: undefined,
+      },
+    });
+  });
+
+  it("does not classify normal bare domains as file candidates", () => {
+    expect(
+      classifyAssistantFileLink("google.com", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+    expect(
+      classifyAssistantFileLink("example.com", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+    expect(
+      classifyAssistantFileLink("openai.com/path", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+  });
+
+  it("does not classify plain inline code words or identifiers as file candidates", () => {
+    for (const value of [
+      "main",
+      "origin/main",
+      "1f7fc232b",
+      "25994904967",
+      "babysit main 1f7fc232b",
+    ]) {
+      expect(
+        classifyAssistantFileLink(value, {
+          workspaceRoot: "/Users/test/project",
+        }),
+      ).toBeNull();
+    }
+  });
+
+  it("does not classify shell commands containing path arguments as file candidates", () => {
+    expect(
+      classifyAssistantFileLink(
+        "npm run lint -- packages/app/src/stores/workspace-layout-actions.ts packages/app/src/stores/workspace-layout-store.ts packages/app/src/screens/workspace/workspace-screen.tsx",
+        {
+          workspaceRoot: "/Users/test/project",
+        },
+      ),
+    ).toBeNull();
+  });
+});
+
 describe("parseAssistantFileLink", () => {
+  it("resolves bare markdown filenames against the active workspace", () => {
+    expect(
+      parseAssistantFileLink("dumm.md", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      raw: "dumm.md",
+      path: "/Users/test/project/dumm.md",
+      lineStart: undefined,
+      lineEnd: undefined,
+    });
+  });
+
+  it("resolves bare source filenames with line suffixes against the active workspace", () => {
+    expect(
+      parseAssistantFileLink("file.ts:12", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      raw: "file.ts:12",
+      path: "/Users/test/project/file.ts",
+      lineStart: 12,
+      lineEnd: undefined,
+    });
+  });
+
+  it("rejects bare domains and domain-like paths", () => {
+    expect(
+      parseAssistantFileLink("google.com", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+    expect(
+      parseAssistantFileLink("google.com:80", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+    expect(
+      parseAssistantFileLink("openai.com/path", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
+  });
+
+  it("resolves relative paths against the active workspace", () => {
+    expect(
+      parseAssistantFileLink("src/components/message.tsx#L33", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toEqual({
+      raw: "src/components/message.tsx#L33",
+      path: "/Users/test/project/src/components/message.tsx",
+      lineStart: 33,
+      lineEnd: undefined,
+    });
+  });
+
   it("parses absolute POSIX hrefs inside the active workspace", () => {
     expect(
       parseAssistantFileLink("/Users/test/project/src/app.tsx#L33", {
@@ -146,6 +346,11 @@ describe("parseAssistantFileLink", () => {
 
   it("rejects external URLs", () => {
     expect(parseAssistantFileLink("https://example.com/Users/test/project/src/app.tsx")).toBeNull();
+    expect(
+      parseAssistantFileLink("http://dumm.md", {
+        workspaceRoot: "/Users/test/project",
+      }),
+    ).toBeNull();
   });
 
   it("rejects invalid line fragments", () => {

packages/app/src/assistant-file-links/parse.ts

@@ -1,4 +1,4 @@
-import { isAbsolutePath } from "./path";
+import { isAbsolutePath } from "@/utils/path";
 
 export interface InlinePathTarget {
   raw: string;
@@ -8,12 +8,86 @@ export interface InlinePathTarget {
 }
 
 const FILE_PROTOCOL = "file:";
-const INLINE_LINE_FRAGMENT = /^L([0-9]+)(?:-L?([0-9]+))?$/i;
+const INLINE_LINE_FRAGMENT = /^L([0-9]+)(?:C[0-9]+)?(?:-L?([0-9]+)(?:C[0-9]+)?)?$/i;
+const INLINE_COLON_LINE_SUFFIX = /^(.+?):([0-9]+)(?::[0-9]+)?(?:-([0-9]+)(?::[0-9]+)?)?$/;
+const INLINE_PAREN_LINE_SUFFIX = /^(.+?)\(([0-9]+)(?:,[0-9]+)?(?:-([0-9]+)(?:,[0-9]+)?)?\)$/;
+const INLINE_WORD_LINE_SUFFIX = /^(.+?)\s+lines?\s+([0-9]+)(?:-([0-9]+))?$/i;
+const ASSISTANT_FILE_EXTENSIONS = new Set([
+  "astro",
+  "bash",
+  "c",
+  "cc",
+  "cjs",
+  "cpp",
+  "cs",
+  "css",
+  "cts",
+  "cxx",
+  "env",
+  "fish",
+  "go",
+  "gql",
+  "gradle",
+  "graphql",
+  "h",
+  "hpp",
+  "htm",
+  "html",
+  "ini",
+  "java",
+  "js",
+  "json",
+  "jsonc",
+  "jsx",
+  "kt",
+  "kts",
+  "less",
+  "lock",
+  "lua",
+  "md",
+  "mdx",
+  "mjs",
+  "mts",
+  "php",
+  "proto",
+  "py",
+  "rb",
+  "rs",
+  "sass",
+  "scss",
+  "sh",
+  "sql",
+  "svelte",
+  "swift",
+  "toml",
+  "ts",
+  "tsx",
+  "txt",
+  "vue",
+  "xml",
+  "yaml",
+  "yml",
+  "zsh",
+]);
 
 export interface AssistantHrefParseOptions {
   workspaceRoot?: string;
 }
 
+export type AssistantFileLinkClassification =
+  | {
+      kind: "external";
+      raw: string;
+    }
+  | {
+      kind: "directFile";
+      target: InlinePathTarget;
+    }
+  | {
+      kind: "ambiguousFileCandidate";
+      target: InlinePathTarget;
+    };
+
 export interface NormalizedInlinePathTarget {
   directory: string;
   file?: string;
@@ -71,7 +145,10 @@ export function parseInlinePathToken(value: string): InlinePathTarget | null {
     return null;
   }
 
-  const match = trimmed.match(/^(.+?):([0-9]+)(?:-([0-9]+))?$/);
+  const match =
+    trimmed.match(INLINE_COLON_LINE_SUFFIX) ??
+    trimmed.match(INLINE_PAREN_LINE_SUFFIX) ??
+    trimmed.match(INLINE_WORD_LINE_SUFFIX);
   if (!match) {
     return null;
   }
@@ -172,6 +249,45 @@ function parseAssistantInlinePathLink(
   };
 }
 
+export function classifyAssistantFileLink(
+  value: string,
+  options: AssistantHrefParseOptions = {},
+): AssistantFileLinkClassification | null {
+  const raw = value ?? "";
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  if (isExternalHref(trimmed)) {
+    return {
+      kind: "external",
+      raw,
+    };
+  }
+
+  if (/\s/.test(trimmed)) {
+    return null;
+  }
+
+  const target = parseAssistantFileLink(trimmed, options);
+  if (!target) {
+    return null;
+  }
+
+  if (isAmbiguousWorkspaceCandidate(trimmed, target, options.workspaceRoot)) {
+    return {
+      kind: "ambiguousFileCandidate",
+      target,
+    };
+  }
+
+  return {
+    kind: "directFile",
+    target,
+  };
+}
+
 export function parseAssistantFileLink(
   value: string,
   options: AssistantHrefParseOptions = {},
@@ -186,7 +302,7 @@ export function parseAssistantFileLink(
     return null;
   }
 
-  if (trimmed.includes("://")) {
+  if (isExternalHref(trimmed)) {
     return null;
   }
 
@@ -216,6 +332,13 @@ export function parseAssistantFileLink(
     };
   }
 
+  const relativeTarget = parseWorkspaceRelativeFileLink(trimmed, {
+    workspaceRoot: options.workspaceRoot,
+  });
+  if (relativeTarget) {
+    return relativeTarget;
+  }
+
   if (!isAbsolutePath(trimmed)) {
     return null;
   }
@@ -248,6 +371,96 @@ export function parseAssistantFileLink(
   };
 }
 
+export function isFileLookingAssistantToken(value: string): boolean {
+  const normalized = normalizePathToken(value);
+  if (
+    !normalized ||
+    /\s/.test(normalized) ||
+    normalized.includes("?") ||
+    normalized.includes("://")
+  ) {
+    return false;
+  }
+
+  const path = getHeuristicLocalPath(normalized);
+  if (!path) {
+    return false;
+  }
+
+  return isPlausibleAssistantLocalPath(path);
+}
+
+function parseWorkspaceRelativeFileLink(
+  value: string,
+  options: AssistantHrefParseOptions,
+): InlinePathTarget | null {
+  const workspaceRoot = normalizePathInput(options.workspaceRoot);
+  if (!workspaceRoot) {
+    return null;
+  }
+
+  const parsed = parseLocalPathParts(value);
+  if (!parsed || isAbsolutePath(parsed.path)) {
+    return null;
+  }
+
+  const normalizedPath = resolveRelativePathUnderRoot(parsed.path, workspaceRoot);
+  if (!normalizedPath) {
+    return null;
+  }
+
+  return {
+    raw: value,
+    path: normalizedPath,
+    ...parsed.lines,
+  };
+}
+
+function parseLocalPathParts(
+  value: string,
+): { path: string; lines: Pick<InlinePathTarget, "lineStart" | "lineEnd"> } | null {
+  const normalized = normalizePathToken(value);
+  if (!normalized || normalized.includes("?")) {
+    return null;
+  }
+
+  const hashIndex = normalized.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? normalized.slice(0, hashIndex) : normalized;
+  const hash = hashIndex >= 0 ? normalized.slice(hashIndex) : "";
+  const fragmentLines = parseLineFragment(hash);
+  if (!fragmentLines) {
+    return null;
+  }
+
+  const inlinePathTarget = parseInlinePathToken(beforeHash);
+  if (inlinePathTarget) {
+    if (!isPlausibleAssistantLocalPath(inlinePathTarget.path)) {
+      return null;
+    }
+
+    return {
+      path: inlinePathTarget.path,
+      lines: {
+        lineStart: inlinePathTarget.lineStart,
+        lineEnd: inlinePathTarget.lineEnd,
+      },
+    };
+  }
+
+  if (!beforeHash || beforeHash.includes(":")) {
+    return null;
+  }
+
+  if (!isPlausibleAssistantLocalPath(beforeHash)) {
+    return null;
+  }
+
+  return {
+    path: beforeHash,
+    lines: fragmentLines,
+  };
+}
+
 export function normalizeInlinePathTarget(
   rawPath: string,
   cwd?: string,
@@ -308,6 +521,139 @@ function isAllowedAbsolutePath(pathValue: string, workspaceRoot?: string): boole
   return comparePath === compareWorkspaceRoot || comparePath.startsWith(comparePrefix);
 }
 
+function isExternalHref(value: string): boolean {
+  if (value.includes("://")) {
+    return !value.toLowerCase().startsWith(`${FILE_PROTOCOL}//`);
+  }
+
+  const inlinePathTarget = parseInlinePathToken(value);
+  if (inlinePathTarget) {
+    return false;
+  }
+
+  return /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value) && !/^[A-Za-z]:[\\/]/.test(value);
+}
+
+function isAmbiguousWorkspaceCandidate(
+  value: string,
+  target: InlinePathTarget,
+  workspaceRoot?: string,
+): boolean {
+  const normalizedWorkspaceRoot = normalizePathInput(workspaceRoot);
+  if (!normalizedWorkspaceRoot || !isAllowedAbsolutePath(target.path, normalizedWorkspaceRoot)) {
+    return false;
+  }
+
+  const parsed = parseLocalPathParts(value);
+  if (!parsed || isAbsolutePath(parsed.path)) {
+    return false;
+  }
+
+  return !parsed.path.includes("/");
+}
+
+function getHeuristicLocalPath(value: string): string | null {
+  const hashIndex = value.indexOf("#");
+  const beforeHash = hashIndex >= 0 ? value.slice(0, hashIndex) : value;
+  const hash = hashIndex >= 0 ? value.slice(hashIndex) : "";
+  if (!parseLineFragment(hash)) {
+    return null;
+  }
+
+  const inlinePathTarget = parseInlinePathToken(beforeHash);
+  if (inlinePathTarget) {
+    return inlinePathTarget.path;
+  }
+
+  if (!beforeHash || beforeHash.includes(":")) {
+    return null;
+  }
+
+  return beforeHash;
+}
+
+function isPlausibleAssistantLocalPath(pathValue: string): boolean {
+  const normalized = normalizePathToken(pathValue);
+  if (!normalized) {
+    return false;
+  }
+
+  if (isAbsolutePath(normalized)) {
+    return true;
+  }
+
+  const explicitRelative =
+    normalized.startsWith("./") || normalized.startsWith("../") || normalized.startsWith("~/");
+  if (explicitRelative) {
+    return true;
+  }
+
+  const segments = normalized.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  if (!firstSegment) {
+    return false;
+  }
+
+  if (segments.length > 1) {
+    const lastSegment = segments[segments.length - 1];
+    return !isDomainLikePathSegment(firstSegment) && isPlausibleAssistantFileName(lastSegment);
+  }
+
+  return isPlausibleAssistantFileName(firstSegment);
+}
+
+function isPlausibleAssistantFileName(fileName: string | undefined): boolean {
+  if (!fileName) {
+    return false;
+  }
+
+  if (fileName.startsWith(".") && fileName.length > 1) {
+    return true;
+  }
+
+  const lastDot = fileName.lastIndexOf(".");
+  if (lastDot < 0) {
+    return false;
+  }
+
+  const extension = fileName.slice(lastDot + 1).toLowerCase();
+  return ASSISTANT_FILE_EXTENSIONS.has(extension);
+}
+
+function isDomainLikePathSegment(segment: string): boolean {
+  return /^[A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+$/.test(segment);
+}
+
+function resolveRelativePathUnderRoot(pathValue: string, workspaceRoot: string): string | null {
+  const normalizedPath = normalizePathToken(pathValue);
+  if (!normalizedPath || isAbsolutePath(normalizedPath)) {
+    return null;
+  }
+
+  const root = workspaceRoot.replace(/\/+$/, "") || "/";
+  const pathSegments = normalizedPath.split("/");
+  const resolvedSegments: string[] = [];
+  for (const segment of pathSegments) {
+    if (!segment || segment === ".") {
+      continue;
+    }
+    if (segment === "..") {
+      if (resolvedSegments.length === 0) {
+        return null;
+      }
+      resolvedSegments.pop();
+      continue;
+    }
+    resolvedSegments.push(segment);
+  }
+
+  if (resolvedSegments.length === 0) {
+    return root;
+  }
+
+  return root === "/" ? `/${resolvedSegments.join("/")}` : `${root}/${resolvedSegments.join("/")}`;
+}
+
 function normalizeFileUrlPath(pathname: string): string | null {
   if (!pathname) {
     return null;

packages/app/src/assistant-file-links/resolver.test.ts

@@ -0,0 +1,604 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createAssistantFileLinkResolver,
+  getAssistantFileLinkToken,
+  type AssistantFileLinkContext,
+  type DirectorySuggestionEntry,
+  type DirectorySuggestionResult,
+} from "./resolver";
+import type { OpenFileDisposition } from "@/workspace/file-open";
+import type { InlinePathTarget } from "./parse";
+
+const CONTEXT: AssistantFileLinkContext = {
+  serverId: "server-1",
+  workspaceRoot: "/Users/test/project",
+};
+
+function resolvedSuggestions(
+  entries: DirectorySuggestionResult["entries"],
+): DirectorySuggestionResult {
+  return { entries, error: null };
+}
+
+function createDeferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: unknown) => void;
+  const promise = new Promise<T>((promiseResolve, promiseReject) => {
+    resolve = promiseResolve;
+    reject = promiseReject;
+  });
+
+  return { promise, resolve, reject };
+}
+
+interface DirectorySearch {
+  query: string;
+  cwd: string;
+  includeFiles: true;
+  includeDirectories: false;
+  matchMode: "suffix";
+  limit: number;
+}
+
+interface OpenedFile {
+  target: InlinePathTarget;
+  disposition: OpenFileDisposition;
+}
+
+class FakeWorkspaceFiles {
+  readonly searches: DirectorySearch[] = [];
+  readonly openedFiles: OpenedFile[] = [];
+  readonly unresolvedTokens: string[] = [];
+
+  constructor(private readonly entriesByQuery: Record<string, DirectorySuggestionEntry[]>) {}
+
+  createResolver() {
+    return createAssistantFileLinkResolver({
+      getDirectorySuggestions: this.getDirectorySuggestions,
+      openWorkspaceFile: this.openWorkspaceFile,
+      openExternalUrl: async () => {},
+      onUnresolvedFileCandidate: this.onUnresolvedFileCandidate,
+    });
+  }
+
+  private getDirectorySuggestions = async (
+    search: DirectorySearch,
+  ): Promise<DirectorySuggestionResult> => {
+    this.searches.push(search);
+    return resolvedSuggestions(this.entriesByQuery[search.query] ?? []);
+  };
+
+  private openWorkspaceFile = (
+    target: InlinePathTarget,
+    disposition: OpenFileDisposition,
+  ): void => {
+    this.openedFiles.push({ target, disposition });
+  };
+
+  private onUnresolvedFileCandidate = (token: string): void => {
+    this.unresolvedTokens.push(token);
+  };
+}
+
+describe("assistant file link resolver", () => {
+  it("dedupes in-flight prefetches and serves the click from cache", async () => {
+    const suggestions = vi.fn(async () =>
+      resolvedSuggestions([{ path: "src/dumm.md", kind: "file" }]),
+    );
+    const openWorkspaceFile = vi.fn();
+    const openExternalUrl = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl,
+    });
+    const source = { href: "http://dumm.md", text: "dumm.md", markup: "linkify" };
+
+    await Promise.all([
+      resolver.prefetch({ context: CONTEXT, source }),
+      resolver.prefetch({ context: CONTEXT, source }),
+    ]);
+    const result = await resolver.open({ context: CONTEXT, source, disposition: "main" });
+
+    expect(suggestions).toHaveBeenCalledTimes(1);
+    expect(suggestions).toHaveBeenCalledWith({
+      query: "dumm.md",
+      cwd: "/Users/test/project",
+      includeFiles: true,
+      includeDirectories: false,
+      matchMode: "suffix",
+      limit: 1,
+    });
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "dumm.md",
+        path: "/Users/test/project/src/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+    expect(openExternalUrl).not.toHaveBeenCalled();
+    expect(result.opened).toBe(true);
+  });
+
+  it("click consumes an in-flight hover resolution", async () => {
+    const deferred = createDeferred<DirectorySuggestionResult>();
+    const suggestions = vi.fn(() => deferred.promise);
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+    });
+    const source = { href: "http://dumm.md", text: "dumm.md", sourceInfo: "auto" };
+
+    const prefetch = resolver.prefetch({ context: CONTEXT, source });
+    const opened = resolver.open({ context: CONTEXT, source, disposition: "main" });
+    deferred.resolve(resolvedSuggestions([{ path: "docs/dumm.md", kind: "file" }]));
+
+    await prefetch;
+    const result = await opened;
+
+    expect(suggestions).toHaveBeenCalledTimes(1);
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "dumm.md",
+        path: "/Users/test/project/docs/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+    expect(result.opened).toBe(true);
+  });
+
+  it("retries a click after hover prefetch fails to query suggestions", async () => {
+    const suggestions = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("daemon unavailable"))
+      .mockResolvedValueOnce(resolvedSuggestions([{ path: "docs/dumm.md", kind: "file" }]));
+    const openWorkspaceFile = vi.fn();
+    const openExternalUrl = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl,
+    });
+    const source = { href: "http://dumm.md", text: "dumm.md", markup: "linkify" };
+
+    const prefetchResult = await resolver.prefetch({ context: CONTEXT, source });
+    const openResult = await resolver.open({ context: CONTEXT, source, disposition: "main" });
+
+    expect(prefetchResult).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "dumm.md",
+    });
+    expect(suggestions).toHaveBeenCalledTimes(2);
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "dumm.md",
+        path: "/Users/test/project/docs/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+    expect(openExternalUrl).not.toHaveBeenCalled();
+    expect(openResult.opened).toBe(true);
+  });
+
+  it("does not cache unresolved candidates", async () => {
+    const suggestions = vi
+      .fn()
+      .mockResolvedValueOnce(resolvedSuggestions([]))
+      .mockResolvedValueOnce(resolvedSuggestions([{ path: "docs/dumm.md", kind: "file" }]));
+    const openWorkspaceFile = vi.fn();
+    const openExternalUrl = vi.fn();
+    const onUnresolvedFileCandidate = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl,
+      onUnresolvedFileCandidate,
+    });
+    const source = { href: "http://dumm.md", text: "dumm.md", markup: "linkify" };
+
+    const first = await resolver.open({ context: CONTEXT, source, disposition: "main" });
+    const second = await resolver.open({ context: CONTEXT, source, disposition: "main" });
+
+    expect(first).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "dumm.md",
+      opened: false,
+    });
+    expect(second.opened).toBe(true);
+    expect(suggestions).toHaveBeenCalledTimes(2);
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "dumm.md",
+        path: "/Users/test/project/docs/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+    expect(openExternalUrl).not.toHaveBeenCalled();
+    expect(onUnresolvedFileCandidate).toHaveBeenCalledTimes(1);
+  });
+
+  it("keys cache entries by server, workspace, and token", async () => {
+    const suggestions = vi
+      .fn()
+      .mockResolvedValueOnce(resolvedSuggestions([{ path: "one/dumm.md", kind: "file" }]))
+      .mockResolvedValueOnce(resolvedSuggestions([{ path: "two/dumm.md", kind: "file" }]));
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+    });
+    const source = { href: "http://dumm.md", text: "dumm.md", markup: "linkify" };
+
+    await resolver.open({ context: CONTEXT, source, disposition: "main" });
+    await resolver.open({
+      context: { serverId: "server-1", workspaceRoot: "/Users/test/other" },
+      source,
+      disposition: "main",
+    });
+
+    expect(suggestions).toHaveBeenCalledTimes(2);
+    expect(openWorkspaceFile).toHaveBeenLastCalledWith(
+      {
+        raw: "dumm.md",
+        path: "/Users/test/other/two/dumm.md",
+        lineStart: undefined,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+  });
+
+  it("does not apply stale async results after the active context changes", async () => {
+    const deferred = createDeferred<DirectorySuggestionResult>();
+    let isCurrent = true;
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(() => deferred.promise),
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+      isCurrentContext: () => isCurrent,
+    });
+
+    const opened = resolver.open({
+      context: CONTEXT,
+      source: { href: "http://dumm.md", text: "dumm.md", markup: "linkify" },
+      disposition: "main",
+    });
+    isCurrent = false;
+    deferred.resolve(resolvedSuggestions([{ path: "dumm.md", kind: "file" }]));
+    const result = await opened;
+
+    expect(openWorkspaceFile).not.toHaveBeenCalled();
+    expect(result.opened).toBe(false);
+    expect(result.kind).toBe("file");
+  });
+
+  it("opens direct workspace file links without querying suggestions", async () => {
+    const suggestions = vi.fn(async () => resolvedSuggestions([]));
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+    });
+
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "src/components/message.tsx#L33" },
+      disposition: "main",
+    });
+
+    expect(suggestions).not.toHaveBeenCalled();
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "src/components/message.tsx#L33",
+        path: "/Users/test/project/src/components/message.tsx",
+        lineStart: 33,
+        lineEnd: undefined,
+      },
+      "main",
+    );
+    expect(result.opened).toBe(true);
+  });
+
+  it("preserves direct workspace file line ranges", async () => {
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(async () => resolvedSuggestions([])),
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+    });
+
+    await resolver.open({
+      context: CONTEXT,
+      source: { href: "src/components/message.tsx:33-40" },
+      disposition: "main",
+    });
+
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "src/components/message.tsx:33-40",
+        path: "/Users/test/project/src/components/message.tsx",
+        lineStart: 33,
+        lineEnd: 40,
+      },
+      "main",
+    );
+  });
+
+  it("opens basename line refs when the daemon returns that exact filename", async () => {
+    const workspaceFiles = new FakeWorkspaceFiles({
+      "file.ts": [{ path: "packages/app/src/file.ts", kind: "file" }],
+    });
+    const resolver = workspaceFiles.createResolver();
+
+    const result = await resolver.open({
+      context: { ...CONTEXT, workspaceRoot: "/Users/test/project" },
+      source: {
+        href: "file.ts:12",
+        text: "file.ts:12",
+        sourceType: "inline-code",
+      },
+      disposition: "main",
+    });
+
+    expect(workspaceFiles.searches).toEqual([
+      {
+        query: "file.ts",
+        cwd: "/Users/test/project",
+        includeFiles: true,
+        includeDirectories: false,
+        matchMode: "suffix",
+        limit: 1,
+      },
+    ]);
+    expect(workspaceFiles.openedFiles).toEqual([
+      {
+        target: {
+          raw: "file.ts:12",
+          path: "/Users/test/project/packages/app/src/file.ts",
+          lineStart: 12,
+          lineEnd: undefined,
+        },
+        disposition: "main",
+      },
+    ]);
+    expect(result.opened).toBe(true);
+  });
+
+  it("reports inline-code subpaths as unresolved when suffix suggestions find no file", async () => {
+    const workspaceFiles = new FakeWorkspaceFiles({});
+    const resolver = workspaceFiles.createResolver();
+
+    const result = await resolver.open({
+      context: { ...CONTEXT, workspaceRoot: "/Users/test/project" },
+      source: {
+        href: "src/file.ts",
+        text: "src/file.ts",
+        sourceType: "inline-code",
+      },
+      disposition: "main",
+    });
+
+    expect(workspaceFiles.searches).toEqual([
+      {
+        query: "src/file.ts",
+        cwd: "/Users/test/project",
+        includeFiles: true,
+        includeDirectories: false,
+        matchMode: "suffix",
+        limit: 1,
+      },
+    ]);
+    expect(workspaceFiles.openedFiles).toEqual([]);
+    expect(workspaceFiles.unresolvedTokens).toEqual(["src/file.ts"]);
+    expect(result).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "src/file.ts",
+      opened: false,
+    });
+  });
+
+  it("passes side open disposition to workspace file links", async () => {
+    const openWorkspaceFile = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(async () => resolvedSuggestions([])),
+      openWorkspaceFile,
+      openExternalUrl: vi.fn(),
+    });
+
+    await resolver.open({
+      context: CONTEXT,
+      source: { href: "src/components/message.tsx#L33" },
+      disposition: "side",
+    });
+
+    expect(openWorkspaceFile).toHaveBeenCalledWith(
+      {
+        raw: "src/components/message.tsx#L33",
+        path: "/Users/test/project/src/components/message.tsx",
+        lineStart: 33,
+        lineEnd: undefined,
+      },
+      "side",
+    );
+  });
+
+  it("keeps explicit external URLs external", async () => {
+    const openExternalUrl = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(async () => resolvedSuggestions([])),
+      openWorkspaceFile: vi.fn(),
+      openExternalUrl,
+    });
+
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "http://dumm.md", text: "dumm.md" },
+      disposition: "main",
+    });
+
+    expect(openExternalUrl).toHaveBeenCalledWith("http://dumm.md");
+    expect(result).toEqual({
+      kind: "external",
+      url: "http://dumm.md",
+      opened: true,
+    });
+  });
+
+  it("keeps auto-linkified normal domains external", async () => {
+    const suggestions = vi.fn(async () => resolvedSuggestions([]));
+    const openExternalUrl = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile: vi.fn(),
+      openExternalUrl,
+    });
+
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "http://google.com", text: "google.com", markup: "linkify" },
+      disposition: "main",
+    });
+
+    expect(suggestions).not.toHaveBeenCalled();
+    expect(openExternalUrl).toHaveBeenCalledWith("http://google.com");
+    expect(result).toEqual({
+      kind: "external",
+      url: "http://google.com",
+      opened: true,
+    });
+  });
+
+  it("keeps auto-linkified normal domain paths external", async () => {
+    const suggestions = vi.fn(async () => resolvedSuggestions([]));
+    const openExternalUrl = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: suggestions,
+      openWorkspaceFile: vi.fn(),
+      openExternalUrl,
+    });
+
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "http://openai.com/path", text: "openai.com/path", sourceInfo: "auto" },
+      disposition: "main",
+    });
+
+    expect(suggestions).not.toHaveBeenCalled();
+    expect(openExternalUrl).toHaveBeenCalledWith("http://openai.com/path");
+    expect(result).toEqual({
+      kind: "external",
+      url: "http://openai.com/path",
+      opened: true,
+    });
+  });
+
+  it("does not open unresolved linkified markdown filenames in the browser", async () => {
+    const openWorkspaceFile = vi.fn();
+    const openExternalUrl = vi.fn();
+    const onUnresolvedFileCandidate = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(async () => resolvedSuggestions([])),
+      openWorkspaceFile,
+      openExternalUrl,
+      onUnresolvedFileCandidate,
+    });
+
+    const prefetchResult = await resolver.prefetch({
+      context: CONTEXT,
+      source: { href: "http://dumm.md", text: "dumm.md", sourceInfo: "auto" },
+    });
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "http://dumm.md", text: "dumm.md", sourceInfo: "auto" },
+      disposition: "main",
+    });
+
+    expect(openWorkspaceFile).not.toHaveBeenCalled();
+    expect(openExternalUrl).not.toHaveBeenCalled();
+    expect(prefetchResult).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "dumm.md",
+    });
+    expect(onUnresolvedFileCandidate).toHaveBeenCalledTimes(1);
+    expect(onUnresolvedFileCandidate).toHaveBeenCalledWith("dumm.md");
+    expect(result).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "dumm.md",
+      opened: false,
+    });
+  });
+
+  it("keeps failed ambiguous resolution out of the browser", async () => {
+    const openExternalUrl = vi.fn();
+    const onUnresolvedFileCandidate = vi.fn();
+    const resolver = createAssistantFileLinkResolver({
+      getDirectorySuggestions: vi.fn(async () => {
+        throw new Error("daemon unavailable");
+      }),
+      openWorkspaceFile: vi.fn(),
+      openExternalUrl,
+      onUnresolvedFileCandidate,
+    });
+
+    const result = await resolver.open({
+      context: CONTEXT,
+      source: { href: "http://dumm.md", text: "dumm.md", markup: "linkify" },
+      disposition: "main",
+    });
+
+    expect(openExternalUrl).not.toHaveBeenCalled();
+    expect(onUnresolvedFileCandidate).toHaveBeenCalledWith("dumm.md");
+    expect(result).toEqual({
+      kind: "unresolvedFileCandidate",
+      token: "dumm.md",
+      opened: false,
+    });
+  });
+
+  it("uses rendered text for markdown-it linkified tokens and href for explicit links", () => {
+    expect(
+      getAssistantFileLinkToken({
+        href: "http://dumm.md",
+        text: "dumm.md",
+        markup: "linkify",
+        sourceInfo: "auto",
+      }),
+    ).toBe("dumm.md");
+    expect(
+      getAssistantFileLinkToken({
+        href: "http://google.com",
+        text: "google.com",
+        markup: "linkify",
+        sourceInfo: "auto",
+      }),
+    ).toBe("http://google.com");
+    expect(
+      getAssistantFileLinkToken({
+        href: "http://dumm.md",
+        text: "dumm.md",
+        markup: "",
+        sourceInfo: "",
+      }),
+    ).toBe("http://dumm.md");
+    expect(
+      getAssistantFileLinkToken({
+        href: "workspace-git-service.ts:1553",
+        text: "workspace-git-service.ts:1553",
+        sourceType: "inline-code",
+      }),
+    ).toBe("workspace-git-service.ts:1553");
+  });
+});

packages/app/src/assistant-file-links/resolver.ts

@@ -0,0 +1,307 @@
+import {
+  classifyAssistantFileLink,
+  isFileLookingAssistantToken,
+  type AssistantFileLinkClassification,
+  type InlinePathTarget,
+} from "./parse";
+import type { OpenFileDisposition } from "@/workspace/file-open";
+
+export interface AssistantFileLinkContext {
+  serverId?: string;
+  workspaceRoot?: string;
+}
+
+export interface AssistantFileLinkSource {
+  href: string;
+  text?: string;
+  markup?: string;
+  sourceInfo?: string;
+  sourceType?: "inline-code";
+}
+
+export interface DirectorySuggestionEntry {
+  path: string;
+  kind: "file" | "directory";
+}
+
+export interface DirectorySuggestionResult {
+  entries: DirectorySuggestionEntry[];
+  error: string | null;
+}
+
+export interface AssistantFileLinkResolverDependencies {
+  getDirectorySuggestions: (input: {
+    query: string;
+    cwd: string;
+    includeFiles: true;
+    includeDirectories: false;
+    matchMode: "suffix";
+    limit: number;
+  }) => Promise<DirectorySuggestionResult>;
+  openWorkspaceFile: (target: InlinePathTarget, disposition: OpenFileDisposition) => void;
+  openExternalUrl: (url: string) => void | Promise<void>;
+  onUnresolvedFileCandidate?: (token: string) => void;
+  isCurrentContext?: (context: AssistantFileLinkContext) => boolean;
+}
+
+export interface AssistantFileLinkResolver {
+  prefetch(input: AssistantFileLinkPrefetchInput): Promise<ResolvedAssistantFileLink>;
+  open(input: AssistantFileLinkOpenInput): Promise<AssistantFileLinkOpenResult>;
+}
+
+export interface AssistantFileLinkPrefetchInput {
+  context: AssistantFileLinkContext;
+  source: AssistantFileLinkSource;
+}
+
+export interface AssistantFileLinkOpenInput extends AssistantFileLinkPrefetchInput {
+  disposition: OpenFileDisposition;
+}
+
+export type ResolvedAssistantFileLink =
+  | {
+      kind: "external";
+      url: string;
+    }
+  | {
+      kind: "file";
+      target: InlinePathTarget;
+    }
+  | {
+      kind: "unresolvedFileCandidate";
+      token: string;
+    }
+  | {
+      kind: "ignored";
+    };
+
+export type AssistantFileLinkOpenResult = ResolvedAssistantFileLink & {
+  opened: boolean;
+};
+
+type CachedAssistantFileLink = Exclude<ResolvedAssistantFileLink, { kind: "external" }>;
+
+interface ParsedAssistantFileLinkInteraction {
+  token: string;
+  classification: AssistantFileLinkClassification;
+}
+
+export function createAssistantFileLinkResolver(
+  dependencies: AssistantFileLinkResolverDependencies,
+): AssistantFileLinkResolver {
+  const cache = new Map<string, CachedAssistantFileLink>();
+  const inFlight = new Map<string, Promise<CachedAssistantFileLink>>();
+
+  async function resolve(
+    input: AssistantFileLinkPrefetchInput,
+  ): Promise<ResolvedAssistantFileLink> {
+    const parsed = parseInteraction(input);
+    if (!parsed) {
+      return { kind: "ignored" };
+    }
+
+    if (parsed.classification.kind === "external") {
+      return { kind: "external", url: parsed.classification.raw };
+    }
+
+    if (
+      parsed.classification.kind === "directFile" &&
+      !shouldResolveDirectFileThroughSuggestions({
+        context: input.context,
+        source: input.source,
+        token: parsed.token,
+        target: parsed.classification.target,
+      })
+    ) {
+      return { kind: "file", target: parsed.classification.target };
+    }
+
+    const key = getResolutionKey(input.context, parsed.token);
+    const cached = cache.get(key);
+    if (cached) {
+      return cached;
+    }
+
+    const active = inFlight.get(key);
+    if (active) {
+      return active;
+    }
+
+    const request = resolveAmbiguousCandidate({
+      context: input.context,
+      token: parsed.token,
+      target: parsed.classification.target,
+      getDirectorySuggestions: dependencies.getDirectorySuggestions,
+    })
+      .then((result) => {
+        if (result.kind === "file") {
+          cache.set(key, result);
+        }
+        inFlight.delete(key);
+        return result;
+      })
+      .catch((): CachedAssistantFileLink => {
+        inFlight.delete(key);
+        return { kind: "unresolvedFileCandidate", token: parsed.token };
+      });
+
+    inFlight.set(key, request);
+    return request;
+  }
+
+  return {
+    prefetch(input) {
+      return resolve(input);
+    },
+    async open(input) {
+      const resolved = await resolve(input);
+      if (!canApplyResult(input.context, dependencies.isCurrentContext)) {
+        return { ...resolved, opened: false };
+      }
+
+      if (resolved.kind === "file") {
+        dependencies.openWorkspaceFile(resolved.target, input.disposition);
+        return { ...resolved, opened: true };
+      }
+
+      if (resolved.kind === "external") {
+        await dependencies.openExternalUrl(resolved.url);
+        return { ...resolved, opened: true };
+      }
+
+      if (resolved.kind === "unresolvedFileCandidate") {
+        dependencies.onUnresolvedFileCandidate?.(resolved.token);
+      }
+
+      return { ...resolved, opened: false };
+    },
+  };
+}
+
+export function getAssistantFileLinkToken(source: AssistantFileLinkSource): string {
+  if (isLinkifiedSource(source) || source.sourceType === "inline-code") {
+    const text = source.text?.trim();
+    if (text && isFileLookingAssistantToken(text)) {
+      return text;
+    }
+  }
+
+  return source.href;
+}
+
+function parseInteraction(
+  input: AssistantFileLinkPrefetchInput,
+): ParsedAssistantFileLinkInteraction | null {
+  const token = getAssistantFileLinkToken(input.source).trim();
+  if (!token) {
+    return null;
+  }
+
+  const classification = classifyAssistantFileLink(token, {
+    workspaceRoot: input.context.workspaceRoot,
+  });
+  if (!classification) {
+    return null;
+  }
+
+  return { token, classification };
+}
+
+async function resolveAmbiguousCandidate(input: {
+  context: AssistantFileLinkContext;
+  token: string;
+  target: InlinePathTarget;
+  getDirectorySuggestions: AssistantFileLinkResolverDependencies["getDirectorySuggestions"];
+}): Promise<CachedAssistantFileLink> {
+  const workspaceRoot = input.context.workspaceRoot?.trim();
+  if (!workspaceRoot) {
+    return { kind: "unresolvedFileCandidate", token: input.token };
+  }
+
+  const query = getAmbiguousSuggestionQuery(input.target, workspaceRoot);
+  const suggestions = await input.getDirectorySuggestions({
+    query,
+    cwd: workspaceRoot,
+    includeFiles: true,
+    includeDirectories: false,
+    matchMode: "suffix",
+    limit: 1,
+  });
+  const match = suggestions.entries.find((entry) => entry.kind === "file");
+  if (!match || suggestions.error) {
+    return { kind: "unresolvedFileCandidate", token: input.token };
+  }
+
+  return {
+    kind: "file",
+    target: {
+      ...input.target,
+      path: joinWorkspacePath(workspaceRoot, match.path),
+    },
+  };
+}
+
+function getAmbiguousSuggestionQuery(target: InlinePathTarget, workspaceRoot: string): string {
+  const normalizedRoot = workspaceRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalizedPath = target.path.replace(/\\/g, "/");
+  const prefix = `${normalizedRoot}/`;
+  if (normalizedPath.startsWith(prefix)) {
+    return normalizedPath.slice(prefix.length);
+  }
+
+  const lastSlash = normalizedPath.lastIndexOf("/");
+  return lastSlash >= 0 ? normalizedPath.slice(lastSlash + 1) : normalizedPath;
+}
+
+function shouldResolveDirectFileThroughSuggestions(input: {
+  context: AssistantFileLinkContext;
+  source: AssistantFileLinkSource;
+  token: string;
+  target: InlinePathTarget;
+}): boolean {
+  if (input.source.sourceType !== "inline-code") {
+    return false;
+  }
+
+  if (isAbsoluteInlineCodeToken(input.token)) {
+    return false;
+  }
+
+  const workspaceRoot = input.context.workspaceRoot?.trim();
+  if (!workspaceRoot) {
+    return false;
+  }
+
+  const normalizedRoot = workspaceRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalizedPath = input.target.path.replace(/\\/g, "/");
+  return normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+
+function isAbsoluteInlineCodeToken(token: string): boolean {
+  return (
+    token.startsWith("/") ||
+    token.toLowerCase().startsWith("file://") ||
+    /^[A-Za-z]:[\\/]/.test(token)
+  );
+}
+
+function getResolutionKey(context: AssistantFileLinkContext, token: string): string {
+  return [context.serverId ?? "", context.workspaceRoot ?? "", token].join("\0");
+}
+
+function isLinkifiedSource(source: AssistantFileLinkSource): boolean {
+  return source.markup === "linkify" || source.sourceInfo === "auto";
+}
+
+function canApplyResult(
+  context: AssistantFileLinkContext,
+  isCurrentContext: AssistantFileLinkResolverDependencies["isCurrentContext"],
+): boolean {
+  return isCurrentContext ? isCurrentContext(context) : true;
+}
+
+function joinWorkspacePath(workspaceRoot: string, relativePath: string): string {
+  const root = workspaceRoot.replace(/\\/g, "/").replace(/\/+$/, "");
+  const child = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+  return root ? `${root}/${child}` : child;
+}

packages/app/src/assistant-file-links/use-resolver.ts

@@ -0,0 +1,90 @@
+import { useMemo, useRef } from "react";
+import type { DaemonClient } from "@server/client/daemon-client";
+import type { ToastApi } from "@/components/toast-host";
+import {
+  createAssistantFileLinkResolver,
+  type AssistantFileLinkContext,
+  type AssistantFileLinkOpenInput,
+  type AssistantFileLinkPrefetchInput,
+} from "./resolver";
+import type { InlinePathTarget } from "./parse";
+import type { OpenFileDisposition } from "@/workspace/file-open";
+import { openExternalUrl } from "@/utils/open-external-url";
+
+export interface UseAssistantFileLinkResolverOptions {
+  client?: DaemonClient | null;
+  serverId?: string;
+  workspaceRoot?: string;
+  onOpenWorkspaceFile?: (target: InlinePathTarget, disposition: OpenFileDisposition) => void;
+  toast?: ToastApi | null;
+}
+
+export interface AssistantFileLinkActions {
+  prefetch(input: Omit<AssistantFileLinkPrefetchInput, "context">): void;
+  open(input: Omit<AssistantFileLinkOpenInput, "context">): void;
+}
+
+export function useAssistantFileLinkResolver({
+  client,
+  serverId,
+  workspaceRoot,
+  onOpenWorkspaceFile,
+  toast,
+}: UseAssistantFileLinkResolverOptions): AssistantFileLinkActions {
+  const context: AssistantFileLinkContext = useMemo(
+    () => ({
+      serverId,
+      workspaceRoot,
+    }),
+    [serverId, workspaceRoot],
+  );
+  const latestContextRef = useRef(context);
+  latestContextRef.current = context;
+
+  const resolver = useMemo(
+    () =>
+      createAssistantFileLinkResolver({
+        async getDirectorySuggestions(input) {
+          if (!client) {
+            return { entries: [], error: null };
+          }
+
+          const result = await client.getDirectorySuggestions(input);
+          return {
+            entries: result.entries,
+            error: result.error,
+          };
+        },
+        openWorkspaceFile(target, disposition) {
+          onOpenWorkspaceFile?.(target, disposition);
+        },
+        openExternalUrl,
+        onUnresolvedFileCandidate(token) {
+          toast?.show(`No file found for ${token}`, {
+            variant: "error",
+            testID: "assistant-file-link-not-found-toast",
+          });
+        },
+        isCurrentContext(candidate) {
+          const current = latestContextRef.current;
+          return (
+            current.serverId === candidate.serverId &&
+            current.workspaceRoot === candidate.workspaceRoot
+          );
+        },
+      }),
+    [client, onOpenWorkspaceFile, toast],
+  );
+
+  return useMemo(
+    () => ({
+      prefetch(input) {
+        void resolver.prefetch({ ...input, context });
+      },
+      open(input) {
+        void resolver.open({ ...input, context });
+      },
+    }),
+    [context, resolver],
+  );
+}

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

@@ -0,0 +1,130 @@
+import { describe, expect, it } from "vitest";
+import {
+  CLIENT_SLASH_COMMANDS,
+  buildDraftAgentSetup,
+  resolveClientSlashCommand,
+} from "@/client-slash-commands";
+import type { Agent } from "@/stores/session-store";
+
+function createAgent(overrides: Partial<Agent> = {}): Agent {
+  const now = new Date("2026-05-15T00:00:00.000Z");
+  return {
+    serverId: "server-1",
+    id: "agent-1",
+    provider: "codex",
+    status: "idle",
+    createdAt: now,
+    updatedAt: now,
+    lastUserMessageAt: now,
+    lastActivityAt: now,
+    capabilities: {
+      supportsStreaming: true,
+      supportsSessionPersistence: true,
+      supportsDynamicModes: true,
+      supportsMcpServers: false,
+      supportsReasoningStream: false,
+      supportsToolInvocations: true,
+    },
+    currentModeId: "mode-current",
+    availableModes: [],
+    pendingPermissions: [],
+    persistence: null,
+    runtimeInfo: {
+      provider: "codex",
+      sessionId: "session-1",
+      model: "runtime-model",
+      modeId: "runtime-mode",
+      thinkingOptionId: "runtime-thinking",
+    },
+    title: "Agent",
+    cwd: "/repo",
+    model: "agent-model",
+    thinkingOptionId: "think-hard",
+    features: [
+      { type: "toggle", id: "web-search", label: "Web search", value: true },
+      {
+        type: "select",
+        id: "effort",
+        label: "Effort",
+        value: "high",
+        options: [{ id: "high", label: "High" }],
+      },
+    ],
+    parentAgentId: null,
+    labels: {},
+    ...overrides,
+  };
+}
+
+describe("resolveClientSlashCommand", () => {
+  it("declares the exact client commands that execute immediately", () => {
+    expect(CLIENT_SLASH_COMMANDS.map((command) => [command.name, command.execution])).toEqual([
+      ["quit", "immediate"],
+      ["exit", "immediate"],
+      ["q", "immediate"],
+      ["clear", "immediate"],
+      ["new", "immediate"],
+    ]);
+  });
+
+  it("resolves exact client commands after trimming", () => {
+    expect(resolveClientSlashCommand({ text: " /quit ", hasAttachments: false })).toMatchObject({
+      kind: "archive-agent",
+      execution: "immediate",
+    });
+    expect(resolveClientSlashCommand({ text: "/exit", hasAttachments: false })?.kind).toBe(
+      "archive-agent",
+    );
+    expect(resolveClientSlashCommand({ text: "/q", hasAttachments: false })?.kind).toBe(
+      "archive-agent",
+    );
+    expect(resolveClientSlashCommand({ text: "/clear", hasAttachments: false })?.kind).toBe(
+      "replace-agent-with-draft",
+    );
+    expect(resolveClientSlashCommand({ text: "/new", hasAttachments: false })?.kind).toBe(
+      "replace-agent-with-draft",
+    );
+  });
+
+  it("leaves provider commands, arguments, ordinary messages, and attachment submits alone", () => {
+    expect(resolveClientSlashCommand({ text: "/clear now", hasAttachments: false })).toBeNull();
+    expect(resolveClientSlashCommand({ text: "/quit now", hasAttachments: false })).toBeNull();
+    expect(
+      resolveClientSlashCommand({ text: "/provider-command", hasAttachments: false }),
+    ).toBeNull();
+    expect(resolveClientSlashCommand({ text: "hello /quit", hasAttachments: false })).toBeNull();
+    expect(resolveClientSlashCommand({ text: "/quit", hasAttachments: true })).toBeNull();
+  });
+});
+
+describe("buildDraftAgentSetup", () => {
+  it("builds draft setup from the active agent snapshot", () => {
+    expect(buildDraftAgentSetup(createAgent())).toEqual({
+      provider: "codex",
+      cwd: "/repo",
+      modeId: "mode-current",
+      model: "agent-model",
+      thinkingOptionId: "think-hard",
+      featureValues: {
+        "web-search": true,
+        effort: "high",
+      },
+    });
+  });
+
+  it("falls back to runtime model setup when top-level fields are absent", () => {
+    expect(
+      buildDraftAgentSetup(
+        createAgent({
+          currentModeId: null,
+          model: null,
+          thinkingOptionId: null,
+        }),
+      ),
+    ).toMatchObject({
+      modeId: "runtime-mode",
+      model: "runtime-model",
+      thinkingOptionId: "runtime-thinking",
+    });
+  });
+});

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

@@ -0,0 +1,90 @@
+import type { Agent } from "@/stores/session-store";
+import type { WorkspaceDraftTabSetup } from "@/stores/workspace-tabs-store";
+
+export type ClientSlashCommandKind = "archive-agent" | "replace-agent-with-draft";
+export type ClientSlashCommandExecution = "immediate" | "insert";
+
+export interface ClientSlashCommand {
+  name: string;
+  description: string;
+  argumentHint: string;
+  kind: ClientSlashCommandKind;
+  execution: ClientSlashCommandExecution;
+}
+
+export const CLIENT_SLASH_COMMANDS: readonly ClientSlashCommand[] = [
+  {
+    name: "quit",
+    description: "Archive the current agent",
+    argumentHint: "",
+    kind: "archive-agent",
+    execution: "immediate",
+  },
+  {
+    name: "exit",
+    description: "Archive the current agent",
+    argumentHint: "",
+    kind: "archive-agent",
+    execution: "immediate",
+  },
+  {
+    name: "q",
+    description: "Archive the current agent",
+    argumentHint: "",
+    kind: "archive-agent",
+    execution: "immediate",
+  },
+  {
+    name: "clear",
+    description: "Archive this agent and start a fresh draft",
+    argumentHint: "",
+    kind: "replace-agent-with-draft",
+    execution: "immediate",
+  },
+  {
+    name: "new",
+    description: "Archive this agent and start a fresh draft",
+    argumentHint: "",
+    kind: "replace-agent-with-draft",
+    execution: "immediate",
+  },
+];
+
+const COMMAND_BY_NAME = new Map(CLIENT_SLASH_COMMANDS.map((command) => [command.name, command]));
+
+export function resolveClientSlashCommand(input: {
+  text: string;
+  hasAttachments: boolean;
+}): ClientSlashCommand | null {
+  if (input.hasAttachments) {
+    return null;
+  }
+
+  const trimmed = input.text.trim();
+  if (!trimmed.startsWith("/")) {
+    return null;
+  }
+
+  const commandName = trimmed.slice(1);
+  if (!commandName || /\s/.test(commandName)) {
+    return null;
+  }
+
+  return COMMAND_BY_NAME.get(commandName) ?? null;
+}
+
+export function buildDraftAgentSetup(agent: Agent): WorkspaceDraftTabSetup {
+  const featureValues: Record<string, unknown> = {};
+  for (const feature of agent.features ?? []) {
+    featureValues[feature.id] = feature.value;
+  }
+
+  return {
+    provider: agent.provider,
+    cwd: agent.cwd,
+    modeId: agent.currentModeId ?? agent.runtimeInfo?.modeId ?? null,
+    model: agent.model ?? agent.runtimeInfo?.model ?? null,
+    thinkingOptionId: agent.thinkingOptionId ?? agent.runtimeInfo?.thinkingOptionId ?? null,
+    featureValues,
+  };
+}

packages/app/src/components/agent-status-bar.tsx

@@ -16,7 +16,7 @@ import {
   type StyleProp,
   type ViewStyle,
 } from "react-native";
-import { StyleSheet, useUnistyles } from "react-native-unistyles";
+import { StyleSheet, useUnistyles, withUnistyles } from "react-native-unistyles";
 import { useShallow } from "zustand/shallow";
 import { useStoreWithEqualityFn } from "zustand/traditional";
 import {
@@ -27,6 +27,7 @@ import {
   ShieldAlert,
   ShieldCheck,
   ShieldOff,
+  ShieldQuestionMark,
   Zap,
 } from "lucide-react-native";
 import { getProviderIcon } from "@/components/provider-icons";
@@ -57,6 +58,7 @@ import type {
 } from "@server/server/agent/agent-sdk-types";
 import type { AgentProviderDefinition } from "@server/server/agent/provider-manifest";
 import { getModeVisuals, type AgentModeColorTier } from "@server/server/agent/provider-manifest";
+import type { Theme } from "@/styles/theme";
 import {
   getFeatureHighlightColor,
   getFeatureTooltip,
@@ -180,6 +182,22 @@ const MODE_ICONS = {
   ShieldCheck,
   ShieldAlert,
   ShieldOff,
+  ShieldQuestionMark,
+} as const;
+const ThemedShieldCheck = withUnistyles(ShieldCheck);
+const ThemedShieldAlert = withUnistyles(ShieldAlert);
+const ThemedShieldOff = withUnistyles(ShieldOff);
+const ThemedShieldQuestionMark = withUnistyles(ShieldQuestionMark);
+
+const foregroundColorMapping = (theme: Theme) => ({
+  color: theme.colors.foreground,
+});
+
+const MODE_MENU_LEADING_ICONS = {
+  ShieldCheck: <ThemedShieldCheck size={16} uniProps={foregroundColorMapping} />,
+  ShieldAlert: <ThemedShieldAlert size={16} uniProps={foregroundColorMapping} />,
+  ShieldOff: <ThemedShieldOff size={16} uniProps={foregroundColorMapping} />,
+  ShieldQuestionMark: <ThemedShieldQuestionMark size={16} uniProps={foregroundColorMapping} />,
 } as const;
 
 function alwaysTrue() {
@@ -1604,19 +1622,12 @@ function ModeMenuItem({
   selected: boolean;
   onSelectMode?: (modeId: string) => void;
 }) {
-  const { theme } = useUnistyles();
   const visuals = getModeVisuals(provider, mode.id, providerDefinitions);
-  const Icon = visuals?.icon ? MODE_ICONS[visuals.icon] : ShieldCheck;
-
+  const leadingIcon = visuals?.icon ? MODE_MENU_LEADING_ICONS[visuals.icon] : null;
   const handleSelect = useCallback(() => {
     onSelectMode?.(mode.id);
   }, [mode.id, onSelectMode]);
 
-  const leadingIcon = useMemo(
-    () => <Icon size={16} color={theme.colors.foreground} />,
-    [Icon, theme.colors.foreground],
-  );
-
   return (
     <DropdownMenuItem selected={selected} onSelect={handleSelect} leading={leadingIcon}>
       {mode.label}

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

@@ -35,6 +35,7 @@ describe("buildAgentStreamRenderModel", () => {
     const head = [assistantMessage("live-a", 121)];
 
     const model = buildAgentStreamRenderModel({
+      agentStatus: "running",
       tail,
       head,
       platform: "web",
@@ -52,6 +53,7 @@ describe("buildAgentStreamRenderModel", () => {
     const head = [assistantMessage("live-a", 3)];
 
     const model = buildAgentStreamRenderModel({
+      agentStatus: "running",
       tail,
       head,
       platform: "web",
@@ -69,12 +71,14 @@ describe("buildAgentStreamRenderModel", () => {
     const secondHead = [assistantMessage("live-b", 4)];
 
     const first = buildAgentStreamRenderModel({
+      agentStatus: "running",
       tail,
       head: firstHead,
       platform: "native",
       isMobileBreakpoint: false,
     });
     const second = buildAgentStreamRenderModel({
+      agentStatus: "running",
       tail,
       head: secondHead,
       platform: "native",
@@ -85,4 +89,73 @@ describe("buildAgentStreamRenderModel", () => {
     expect(first.segments.historyMounted).toBe(second.segments.historyMounted);
     expect(second.segments.liveHead.map((item) => item.id)).toEqual(["live-b"]);
   });
+
+  it("derives running turn timing across committed history and live head", () => {
+    const tail = [userMessage("u1", 1)];
+    const head = [assistantMessage("live-a", 4)];
+
+    const model = buildAgentStreamRenderModel({
+      agentStatus: "running",
+      tail,
+      head,
+      platform: "web",
+      isMobileBreakpoint: false,
+    });
+
+    expect(model.turnTiming.runningStartedAt).toBe(tail[0]?.timestamp);
+    expect(model.turnTiming.byAssistantId.has("live-a")).toBe(false);
+  });
+
+  it("maps completed turn timing to assistant ids across committed history and live head", () => {
+    const tail = [userMessage("u1", 1)];
+    const head = [assistantMessage("live-a", 4)];
+
+    const model = buildAgentStreamRenderModel({
+      agentStatus: "idle",
+      tail,
+      head,
+      platform: "web",
+      isMobileBreakpoint: false,
+    });
+
+    expect(model.turnTiming.runningStartedAt).toBe(null);
+    expect(model.turnTiming.byAssistantId.get("live-a")).toEqual({
+      startedAt: tail[0]?.timestamp,
+      completedAt: head[0]?.timestamp,
+      durationMs: 3000,
+    });
+  });
+
+  it("derives the same timing for native inverted rendering", () => {
+    const tail = [userMessage("u1", 1), assistantMessage("a1", 4)];
+
+    const model = buildAgentStreamRenderModel({
+      agentStatus: "idle",
+      tail,
+      head: [],
+      platform: "native",
+      isMobileBreakpoint: false,
+    });
+
+    expect(model.segments.historyMounted.map((item) => item.id)).toEqual(["a1", "u1"]);
+    expect(model.turnTiming.byAssistantId.get("a1")).toEqual({
+      startedAt: tail[0]?.timestamp,
+      completedAt: tail[1]?.timestamp,
+      durationMs: 3000,
+    });
+  });
+
+  it("does not create completed timing for adjacent user messages", () => {
+    const tail = [userMessage("u1", 1), userMessage("u2", 4)];
+
+    const model = buildAgentStreamRenderModel({
+      agentStatus: "idle",
+      tail,
+      head: [],
+      platform: "web",
+      isMobileBreakpoint: false,
+    });
+
+    expect(model.turnTiming.byAssistantId.size).toBe(0);
+  });
 });

packages/app/src/components/agent-stream-render-model.ts

@@ -1,4 +1,5 @@
 import type { ReactNode } from "react";
+import { deriveStreamTurnTiming, type StreamTurnTiming } from "@/timeline/turn-time";
 import type { StreamItem } from "@/types/stream";
 import {
   findMountedWindowStart,
@@ -26,17 +27,19 @@ export interface StreamHistoryBoundary {
 
 export interface StreamRenderAuxiliary {
   pendingPermissions: ReactNode;
-  workingIndicator: ReactNode;
+  turnFooter: ReactNode;
 }
 
 export interface AgentStreamRenderModel {
   history: StreamItem[];
   segments: StreamRenderSegments;
+  turnTiming: StreamTurnTiming;
   boundary: StreamHistoryBoundary;
   auxiliary: StreamRenderAuxiliary;
 }
 
 export interface BuildAgentStreamRenderModelInput {
+  agentStatus: string;
   tail: StreamItem[];
   head: StreamItem[];
   platform: "web" | "native";
@@ -46,7 +49,7 @@ export interface BuildAgentStreamRenderModelInput {
 const EMPTY_STREAM_ITEMS: StreamItem[] = [];
 const EMPTY_AUXILIARY: StreamRenderAuxiliary = {
   pendingPermissions: null,
-  workingIndicator: null,
+  turnFooter: null,
 };
 
 const orderedTailCache = new WeakMap<StreamItem[], Map<string, StreamItem[]>>();
@@ -55,6 +58,10 @@ const splitHistoryCache = new WeakMap<
   StreamItem[],
   Map<string, Pick<AgentStreamRenderModel, "history" | "segments">>
 >();
+const turnTimingCache = new WeakMap<
+  StreamItem[],
+  WeakMap<StreamItem[], Map<string, StreamTurnTiming>>
+>();
 
 function getOrderedItems(params: {
   cache: WeakMap<StreamItem[], Map<string, StreamItem[]>>;
@@ -127,6 +134,30 @@ function splitOrderedTail(params: {
   return split;
 }
 
+function getTurnTiming(params: {
+  agentStatus: string;
+  tail: StreamItem[];
+  head: StreamItem[];
+}): StreamTurnTiming {
+  let cachedByHead = turnTimingCache.get(params.tail);
+  if (!cachedByHead) {
+    cachedByHead = new WeakMap();
+    turnTimingCache.set(params.tail, cachedByHead);
+  }
+  let cachedByStatus = cachedByHead.get(params.head);
+  if (!cachedByStatus) {
+    cachedByStatus = new Map();
+    cachedByHead.set(params.head, cachedByStatus);
+  }
+  const cached = cachedByStatus.get(params.agentStatus);
+  if (cached) {
+    return cached;
+  }
+  const timing = deriveStreamTurnTiming(params);
+  cachedByStatus.set(params.agentStatus, timing);
+  return timing;
+}
+
 export function buildAgentStreamRenderModel(
   input: BuildAgentStreamRenderModelInput,
 ): AgentStreamRenderModel {
@@ -160,6 +191,11 @@ export function buildAgentStreamRenderModel(
     platform: input.platform,
     isMobileBreakpoint: input.isMobileBreakpoint,
   });
+  const turnTiming = getTurnTiming({
+    agentStatus: input.agentStatus,
+    tail: input.tail,
+    head: input.head,
+  });
 
   return {
     history: splitHistory.history,
@@ -167,6 +203,7 @@ export function buildAgentStreamRenderModel(
       ...splitHistory.segments,
       liveHead: orderedHead,
     },
+    turnTiming,
     boundary: {
       hasVirtualizedHistory: splitHistory.segments.historyVirtualized.length > 0,
       hasMountedHistory: splitHistory.segments.historyMounted.length > 0,

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

@@ -0,0 +1,222 @@
+import React, { memo, useCallback, useMemo, type ReactNode } from "react";
+import { View } from "react-native";
+import { StyleSheet, withUnistyles } from "react-native-unistyles";
+import { MAX_CONTENT_WIDTH } from "@/constants/layout";
+import type { Theme } from "@/styles/theme";
+import type { TurnTiming } from "@/timeline/turn-time";
+import type { StreamItem } from "@/types/stream";
+import {
+  collectAssistantTurnContentForStreamRenderStrategy,
+  type StreamStrategy,
+} from "./agent-stream-render-strategy";
+import { AssistantTurnFooter, LiveElapsed, STREAM_METADATA_FONT_SIZE } from "./message";
+import { SyncedLoader } from "./synced-loader";
+
+const ThemedSyncedLoader = withUnistyles(SyncedLoader);
+const workingIndicatorColorMapping = (theme: Theme) => ({
+  color:
+    theme.colorScheme === "light"
+      ? theme.colors.palette.amber[700]
+      : theme.colors.palette.amber[500],
+});
+
+export type TurnContentStrategy = StreamStrategy;
+
+export interface TurnFooterHost {
+  itemId: string;
+  items: StreamItem[];
+  timing?: TurnTiming;
+  startIndex: number;
+}
+
+export function resolveBottomTurnFooterHost(input: {
+  agentStatus: string;
+  history: StreamItem[];
+  liveHead: StreamItem[];
+  isInverted: boolean;
+  timingByAssistantId: Map<string, TurnTiming>;
+}): TurnFooterHost | null {
+  if (input.agentStatus === "running") {
+    return null;
+  }
+  const usesLiveHead = input.liveHead.length > 0;
+  const footerItems = usesLiveHead ? input.liveHead : input.history;
+  const startIndex = input.isInverted ? 0 : footerItems.length - 1;
+  const item = footerItems[startIndex];
+  if (!item || item.kind !== "assistant_message") {
+    return null;
+  }
+  return {
+    itemId: item.id,
+    items: footerItems,
+    timing: input.timingByAssistantId.get(item.id),
+    startIndex,
+  };
+}
+
+export function shouldRenderCompletedTurnFooter(input: {
+  item: StreamItem;
+  belowItem: StreamItem | undefined;
+  agentStatus: string;
+  suppressTurnFooter: boolean | undefined;
+}): boolean {
+  return (
+    input.item.kind === "assistant_message" &&
+    !input.suppressTurnFooter &&
+    (input.belowItem?.kind === "user_message" ||
+      (input.belowItem === undefined && input.agentStatus !== "running"))
+  );
+}
+
+export const TurnFooter = memo(function TurnFooter({
+  isRunning,
+  inFlightTurnStartedAt,
+  host,
+  strategy,
+}: {
+  isRunning: boolean;
+  inFlightTurnStartedAt: Date | null;
+  host: TurnFooterHost | null;
+  strategy: TurnContentStrategy;
+}) {
+  if (isRunning) {
+    return (
+      <TurnFooterRow>
+        <RunningTurnFooter inFlightTurnStartedAt={inFlightTurnStartedAt} />
+      </TurnFooterRow>
+    );
+  }
+  if (!host) {
+    return null;
+  }
+  return (
+    <CompletedTurnFooterRow
+      strategy={strategy}
+      items={host.items}
+      timing={host.timing}
+      startIndex={host.startIndex}
+    />
+  );
+});
+
+export const CompletedTurnFooterRow = memo(function CompletedTurnFooterRow({
+  strategy,
+  items,
+  timing,
+  startIndex,
+}: {
+  strategy: TurnContentStrategy;
+  items: StreamItem[];
+  timing?: TurnTiming;
+  startIndex: number;
+}) {
+  return (
+    <TurnFooterRow>
+      <CompletedTurnFooter
+        strategy={strategy}
+        items={items}
+        timing={timing}
+        startIndex={startIndex}
+      />
+    </TurnFooterRow>
+  );
+});
+
+const WorkingIndicator = memo(function WorkingIndicator({
+  inFlightTurnStartedAt = null,
+}: {
+  inFlightTurnStartedAt?: Date | null;
+}) {
+  return (
+    <View style={stylesheet.turnFooterContent}>
+      <View style={stylesheet.workingLoader}>
+        <ThemedSyncedLoader size={14} uniProps={workingIndicatorColorMapping} />
+      </View>
+      {inFlightTurnStartedAt ? (
+        <LiveElapsed
+          startedAt={inFlightTurnStartedAt}
+          style={stylesheet.workingElapsed}
+          testID="turn-working-elapsed"
+        />
+      ) : null}
+    </View>
+  );
+});
+
+function RunningTurnFooter({ inFlightTurnStartedAt }: { inFlightTurnStartedAt: Date | null }) {
+  return (
+    <View style={stylesheet.turnFooterSlot} testID="turn-working-indicator">
+      <WorkingIndicator inFlightTurnStartedAt={inFlightTurnStartedAt} />
+    </View>
+  );
+}
+
+function CompletedTurnFooter({
+  strategy,
+  items,
+  timing,
+  startIndex,
+}: {
+  strategy: TurnContentStrategy;
+  items: StreamItem[];
+  timing?: TurnTiming;
+  startIndex: number;
+}) {
+  const getContent = useCallback(
+    () =>
+      collectAssistantTurnContentForStreamRenderStrategy({
+        strategy,
+        items,
+        startIndex,
+      }),
+    [strategy, items, startIndex],
+  );
+  return (
+    <View style={stylesheet.turnFooterSlot}>
+      <AssistantTurnFooter
+        getContent={getContent}
+        completedAt={timing?.completedAt}
+        durationMs={timing?.durationMs}
+      />
+    </View>
+  );
+}
+
+function TurnFooterRow({ children }: { children: ReactNode }) {
+  const rowStyle = useMemo(() => [stylesheet.streamItemWrapper, stylesheet.turnFooterRow], []);
+  return <View style={rowStyle}>{children}</View>;
+}
+
+const stylesheet = StyleSheet.create((theme) => ({
+  streamItemWrapper: {
+    width: "100%",
+    maxWidth: MAX_CONTENT_WIDTH,
+    alignSelf: "center",
+    paddingHorizontal: theme.spacing[2],
+  },
+  turnFooterRow: {
+    marginTop: theme.spacing[4],
+  },
+  turnFooterSlot: {
+    flexDirection: "row",
+    alignItems: "center",
+    alignSelf: "flex-start",
+    minHeight: 24,
+    paddingBottom: theme.spacing[6],
+  },
+  turnFooterContent: {
+    height: 24,
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "flex-start",
+    gap: theme.spacing[3],
+  },
+  workingElapsed: {
+    color: theme.colors.foregroundMuted,
+    fontSize: STREAM_METADATA_FONT_SIZE,
+    fontVariant: ["tabular-nums"],
+  },
+  workingLoader: {
+    marginLeft: -2,
+  },
+}));

packages/app/src/components/agent-stream-view-data.test.ts

@@ -1,20 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { StreamItem } from "@/types/stream";
-import type { NeighborResolver } from "./agent-stream-view-data";
-import {
-  getAssistantBlockSpacing,
-  isSameAssistantBlockGroup,
-  resolveInlineWorkingIndicatorItemId,
-} from "./agent-stream-view-data";
-
-// Minimal forward-order resolver: "below" = next item in array.
-// Matches web strategy rendering order (chronological, top-to-bottom).
-const forwardStrategy: NeighborResolver = {
-  getNeighborItem(items, index, relation) {
-    const neighborIndex = relation === "below" ? index + 1 : index - 1;
-    return items[neighborIndex];
-  },
-};
+import { getAssistantBlockSpacing, isSameAssistantBlockGroup } from "./agent-stream-view-data";
 
 function assistantBlock(params: {
   id: string;
@@ -135,46 +121,3 @@ describe("getAssistantBlockSpacing", () => {
     ).toBe("compactTop");
   });
 });
-
-describe("resolveInlineWorkingIndicatorItemId", () => {
-  it("returns null when the agent is not running", () => {
-    const head = assistantBlock({ id: "head", blockGroupId: "group-1", blockIndex: 0 });
-    expect(resolveInlineWorkingIndicatorItemId("idle", [head], forwardStrategy)).toBeNull();
-  });
-
-  it("returns the last assistant block id when running with a single head block", () => {
-    const head = assistantBlock({ id: "group-1:head", blockGroupId: "group-1", blockIndex: 0 });
-    expect(resolveInlineWorkingIndicatorItemId("running", [head], forwardStrategy)).toBe(
-      "group-1:head",
-    );
-  });
-
-  it("returns null when live head contains only a tool call (uses auxiliary indicator instead)", () => {
-    const tc = toolCallBlock("tool-1");
-    expect(resolveInlineWorkingIndicatorItemId("running", [tc], forwardStrategy)).toBeNull();
-  });
-
-  it("returns the footer assistant block when history and streaming head coexist", () => {
-    const historyBlock = assistantBlock({
-      id: "group-1:block:0",
-      blockGroupId: "group-1",
-      blockIndex: 0,
-    });
-    const streamingBlock = assistantBlock({
-      id: "group-2:head",
-      blockGroupId: "group-2",
-      blockIndex: 0,
-    });
-    // historyBlock is in streamItems (tail), not liveHead — liveHead holds only the streaming block
-    expect(resolveInlineWorkingIndicatorItemId("running", [streamingBlock], forwardStrategy)).toBe(
-      "group-2:head",
-    );
-    expect(
-      resolveInlineWorkingIndicatorItemId(
-        "running",
-        [historyBlock, streamingBlock],
-        forwardStrategy,
-      ),
-    ).toBe("group-2:head");
-  });
-});

packages/app/src/components/agent-stream-view-data.ts

@@ -1,4 +1,5 @@
 import type { StreamItem } from "@/types/stream";
+import { SPACING } from "@/styles/theme";
 
 export function isSameAssistantBlockGroup(params: {
   item: StreamItem | null | undefined;
@@ -28,24 +29,35 @@ export function getAssistantBlockSpacing(params: {
   return "default";
 }
 
-export interface NeighborResolver {
-  getNeighborItem(
-    items: StreamItem[],
-    index: number,
-    relation: "above" | "below",
-  ): StreamItem | undefined;
-}
+const isUserMessageItem = (item?: StreamItem | null) => item?.kind === "user_message";
+const isToolSequenceItem = (item?: StreamItem | null) =>
+  item?.kind === "tool_call" || item?.kind === "thought" || item?.kind === "todo_list";
 
-// null → auxiliary working indicator; non-null → inline footer on that block.
-export function resolveInlineWorkingIndicatorItemId(
-  status: string,
-  liveHeadItems: StreamItem[],
-  strategy: NeighborResolver,
-): string | null {
-  if (status !== "running") return null;
-  const footerItem = liveHeadItems.find((item, index, items) => {
-    if (item.kind !== "assistant_message") return false;
-    return strategy.getNeighborItem(items, index, "below") === undefined;
-  });
-  return footerItem?.id ?? null;
+export function getGapBetweenStreamItems(
+  item: StreamItem | null,
+  belowItem: StreamItem | null,
+): number {
+  if (!item || !belowItem) {
+    return 0;
+  }
+
+  if (isUserMessageItem(item) && isUserMessageItem(belowItem)) {
+    return SPACING[1];
+  }
+  if (isToolSequenceItem(item) && isToolSequenceItem(belowItem)) {
+    return 0;
+  }
+  if (item.kind === "user_message" && isToolSequenceItem(belowItem)) {
+    return SPACING[4];
+  }
+  if (item.kind === "assistant_message" && isToolSequenceItem(belowItem)) {
+    return SPACING[1];
+  }
+  if (isToolSequenceItem(item) && belowItem.kind === "assistant_message") {
+    return SPACING[1];
+  }
+  if (isSameAssistantBlockGroup({ item, other: belowItem })) {
+    return SPACING[3];
+  }
+  return SPACING[4];
 }

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

@@ -17,20 +17,13 @@ import {
   Platform,
   ActivityIndicator,
   type PressableStateCallbackType,
+  type StyleProp,
+  type ViewStyle,
 } from "react-native";
 import { StyleSheet, withUnistyles } from "react-native-unistyles";
-import { useIsCompactFormFactor } from "@/constants/layout";
+import { MAX_CONTENT_WIDTH, useIsCompactFormFactor } from "@/constants/layout";
 import { useMutation } from "@tanstack/react-query";
-import Animated, {
-  FadeIn,
-  FadeOut,
-  cancelAnimation,
-  Easing,
-  useAnimatedStyle,
-  useSharedValue,
-  withRepeat,
-  withTiming,
-} from "react-native-reanimated";
+import Animated, { FadeIn, FadeOut } from "react-native-reanimated";
 import { Check, ChevronDown, X } from "lucide-react-native";
 import { usePanelStore } from "@/stores/panel-store";
 import {
@@ -41,7 +34,6 @@ import {
   ToolCall,
   TodoListCard,
   CompactionMarker,
-  TurnCopyButton,
   MessageOuterSpacingProvider,
   type InlinePathTarget,
 } from "./message";
@@ -63,42 +55,182 @@ import { QuestionFormCard } from "./question-form-card";
 import { ToolCallSheetProvider } from "./tool-call-sheet";
 import {
   buildAgentStreamRenderModel,
-  collectAssistantTurnContentForStreamRenderStrategy,
   getStreamNeighborItem,
   resolveStreamRenderStrategy,
   type AgentStreamRenderModel,
   type StreamSegmentRenderers,
   type StreamViewportHandle,
 } from "./agent-stream-render-strategy";
+import { getAssistantBlockSpacing, getGapBetweenStreamItems } from "./agent-stream-view-data";
 import {
-  getAssistantBlockSpacing,
-  isSameAssistantBlockGroup,
-  resolveInlineWorkingIndicatorItemId,
-} from "./agent-stream-view-data";
+  CompletedTurnFooterRow,
+  resolveBottomTurnFooterHost,
+  shouldRenderCompletedTurnFooter,
+  TurnFooter,
+  type TurnContentStrategy,
+  type TurnFooterHost,
+} from "./agent-stream-turn-footer";
 import {
   type BottomAnchorLocalRequest,
   type BottomAnchorRouteRequest,
 } from "./use-bottom-anchor-controller";
-import { MAX_CONTENT_WIDTH } from "@/constants/layout";
-import { normalizeInlinePathTarget } from "@/utils/inline-path";
+import { normalizeInlinePathTarget } from "@/assistant-file-links";
+import {
+  createWorkspaceFileTabTarget,
+  normalizeWorkspaceFileLocation,
+  type OpenFileDisposition,
+  type WorkspaceFileOpenRequest,
+} from "@/workspace/file-open";
 import { resolveWorkspaceIdByExecutionDirectory } from "@/utils/workspace-execution";
 import { navigateToPreparedWorkspaceTab } from "@/utils/workspace-navigation";
-import { useStableEvent } from "@/hooks/use-stable-event";
-import {
-  getWorkingIndicatorDotStrength,
-  WORKING_INDICATOR_CYCLE_MS,
-  WORKING_INDICATOR_OFFSETS,
-} from "@/utils/working-indicator";
 import { isWeb } from "@/constants/platform";
-import { SPACING, type Theme } from "@/styles/theme";
-
-const isUserMessageItem = (item?: StreamItem) => item?.kind === "user_message";
-const isToolSequenceItem = (item?: StreamItem) =>
-  item?.kind === "tool_call" || item?.kind === "thought" || item?.kind === "todo_list";
+import type { Theme } from "@/styles/theme";
 
 interface StreamItemBoundarySeams {
   aboveItem?: StreamItem | null;
   belowItem?: StreamItem | null;
+  suppressTurnFooter?: boolean;
+}
+
+function renderLiveAuxiliaryNode(input: {
+  pendingPermissions: ReactNode;
+  turnFooter: ReactNode;
+}): ReactNode {
+  if (!input.pendingPermissions && !input.turnFooter) {
+    return null;
+  }
+  return (
+    <>
+      {input.turnFooter}
+      {input.pendingPermissions ? (
+        <View style={stylesheet.contentWrapper}>
+          <View style={stylesheet.listHeaderContent}>{input.pendingPermissions}</View>
+        </View>
+      ) : null}
+    </>
+  );
+}
+
+function renderPendingPermissionsNode(input: {
+  pendingPermissions: PendingPermission[];
+  client: DaemonClient | null;
+}): ReactNode {
+  if (input.pendingPermissions.length === 0) {
+    return null;
+  }
+  return (
+    <View style={stylesheet.permissionsContainer}>
+      {input.pendingPermissions.map((permission) => (
+        <PermissionRequestCard key={permission.key} permission={permission} client={input.client} />
+      ))}
+    </View>
+  );
+}
+
+function renderStreamItemWithTurnFooter(input: {
+  content: ReactNode;
+  item: StreamItem;
+  nextItem: StreamItem | undefined;
+  items: StreamItem[];
+  timing: AgentStreamRenderModel["turnTiming"]["byAssistantId"];
+  index: number;
+  agentStatus: string;
+  suppressTurnFooter: boolean | undefined;
+  strategy: TurnContentStrategy;
+}): ReactNode {
+  if (!input.content) {
+    return null;
+  }
+
+  const showCompletedFooter = shouldRenderCompletedTurnFooter({
+    item: input.item,
+    belowItem: input.nextItem,
+    agentStatus: input.agentStatus,
+    suppressTurnFooter: input.suppressTurnFooter,
+  });
+  const gapBelow = showCompletedFooter
+    ? 0
+    : getGapBetweenStreamItems(input.item, input.nextItem ?? null);
+
+  return (
+    <>
+      <StreamItemWrapper gapBelow={gapBelow}>{input.content}</StreamItemWrapper>
+      {showCompletedFooter ? (
+        <CompletedTurnFooterRow
+          strategy={input.strategy}
+          items={input.items}
+          timing={input.timing.get(input.item.id)}
+          startIndex={input.index}
+        />
+      ) : null}
+    </>
+  );
+}
+
+function renderListEmptyComponent(input: {
+  renderModel: AgentStreamRenderModel;
+  emptyStateStyle: StyleProp<ViewStyle>;
+}): ReactNode {
+  if (
+    input.renderModel.boundary.hasVirtualizedHistory ||
+    input.renderModel.boundary.hasMountedHistory ||
+    input.renderModel.boundary.hasLiveHead ||
+    input.renderModel.auxiliary.pendingPermissions ||
+    input.renderModel.auxiliary.turnFooter
+  ) {
+    return null;
+  }
+
+  return (
+    <View style={input.emptyStateStyle}>
+      <Text style={stylesheet.emptyStateText}>Start chatting with this agent...</Text>
+    </View>
+  );
+}
+
+function renderHistoryStreamItem(input: {
+  item: StreamItem;
+  historyIndexById: Map<string, number>;
+  historyItems: StreamItem[];
+  lastHistoryItem: StreamItem | null;
+  firstLiveHeadItem: StreamItem | null;
+  bottomTurnFooterHost: TurnFooterHost | null;
+  renderStreamItem: (
+    item: StreamItem,
+    index: number,
+    items: StreamItem[],
+    seams?: StreamItemBoundarySeams,
+  ) => ReactNode;
+}): ReactNode {
+  const historyIndex = input.historyIndexById.get(input.item.id);
+  if (historyIndex === undefined) {
+    return null;
+  }
+  const seamBelowItem =
+    input.item.id === input.lastHistoryItem?.id ? input.firstLiveHeadItem : null;
+  return input.renderStreamItem(input.item, historyIndex, input.historyItems, {
+    belowItem: seamBelowItem,
+    suppressTurnFooter: input.item.id === input.bottomTurnFooterHost?.itemId,
+  });
+}
+
+function renderLiveHeadStreamItem(input: {
+  item: StreamItem;
+  index: number;
+  items: StreamItem[];
+  lastHistoryItem: StreamItem | null;
+  bottomTurnFooterHost: TurnFooterHost | null;
+  renderStreamItem: (
+    item: StreamItem,
+    index: number,
+    items: StreamItem[],
+    seams?: StreamItemBoundarySeams,
+  ) => ReactNode;
+}): ReactNode {
+  return input.renderStreamItem(input.item, input.index, input.items, {
+    aboveItem: input.index === 0 ? input.lastHistoryItem : null,
+    suppressTurnFooter: input.item.id === input.bottomTurnFooterHost?.itemId,
+  });
 }
 
 export interface AgentStreamViewHandle {
@@ -115,9 +247,11 @@ export interface AgentStreamViewProps {
   routeBottomAnchorRequest?: BottomAnchorRouteRequest | null;
   isAuthoritativeHistoryReady?: boolean;
   toast?: ToastApi | null;
-  onOpenWorkspaceFile?: (input: { filePath: string }) => void;
+  onOpenWorkspaceFile?: (request: WorkspaceFileOpenRequest) => void;
 }
 
+const EMPTY_STREAM_HEAD: StreamItem[] = [];
+
 const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamViewProps>(
   function AgentStreamView(
     {
@@ -173,11 +307,6 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       agentId,
       toast,
     });
-    const openWorkspaceFile = useStableEvent(function openWorkspaceFile(input: {
-      filePath: string;
-    }) {
-      onOpenWorkspaceFile?.(input);
-    });
     // Keep entry/exit animations off on Android due to RN dispatchDraw crashes
     // tracked in react-native-reanimated#8422.
     const shouldDisableEntryExitAnimations = Platform.OS === "android";
@@ -194,7 +323,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     }, [agentId]);
 
     const handleInlinePathPress = useCallback(
-      (target: InlinePathTarget) => {
+      (target: InlinePathTarget, disposition: OpenFileDisposition) => {
         if (!target.path) {
           return;
         }
@@ -205,8 +334,20 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         }
 
         if (normalized.file) {
+          const location = normalizeWorkspaceFileLocation({
+            path: normalized.file,
+            lineStart: target.lineStart,
+            lineEnd: target.lineEnd,
+          });
+          if (!location) {
+            return;
+          }
+
           if (onOpenWorkspaceFile) {
-            openWorkspaceFile({ filePath: normalized.file });
+            onOpenWorkspaceFile({
+              location,
+              disposition,
+            });
             return;
           }
 
@@ -214,7 +355,7 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             navigateToPreparedWorkspaceTab({
               serverId: resolvedServerId,
               workspaceId,
-              target: { kind: "file", path: normalized.file },
+              target: createWorkspaceFileTabTarget(location),
             });
           }
           return;
@@ -245,35 +386,26 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         requestDirectoryListing,
         resolvedServerId,
         setExplorerTabForCheckout,
-        openWorkspaceFile,
         workspaceId,
       ],
     );
 
     const handleToolCallOpenFile = useCallback(
       (filePath: string) => {
-        handleInlinePathPress({ raw: filePath, path: filePath });
+        handleInlinePathPress({ raw: filePath, path: filePath }, "main");
       },
       [handleInlinePathPress],
     );
 
     const baseRenderModel = useMemo(() => {
       return buildAgentStreamRenderModel({
+        agentStatus: agent.status,
         tail: streamItems,
-        head: streamHead ?? [],
+        head: streamHead ?? EMPTY_STREAM_HEAD,
         platform: isWeb ? "web" : "native",
         isMobileBreakpoint: isMobile,
       });
-    }, [isMobile, streamHead, streamItems]);
-    const inlineWorkingIndicatorItemId = useMemo(
-      () =>
-        resolveInlineWorkingIndicatorItemId(
-          agent.status,
-          baseRenderModel.segments.liveHead,
-          streamRenderStrategy,
-        ),
-      [agent.status, baseRenderModel.segments.liveHead, streamRenderStrategy],
-    );
+    }, [agent.status, isMobile, streamHead, streamItems]);
     useImperativeHandle(
       ref,
       () => ({
@@ -291,39 +423,6 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       viewportRef.current?.scrollToBottom("jump-to-bottom");
     }, []);
 
-    const tightGap = SPACING[1];
-    const assistantBlockGap = SPACING[3];
-    const looseGap = SPACING[4];
-
-    const getGapBetween = useCallback(
-      (item: StreamItem | null, belowItem: StreamItem | null) => {
-        if (!item || !belowItem) {
-          return 0;
-        }
-
-        if (isUserMessageItem(item) && isUserMessageItem(belowItem)) {
-          return tightGap;
-        }
-        if (isToolSequenceItem(item) && isToolSequenceItem(belowItem)) {
-          return 0;
-        }
-        if (item.kind === "user_message" && isToolSequenceItem(belowItem)) {
-          return looseGap;
-        }
-        if (item.kind === "assistant_message" && isToolSequenceItem(belowItem)) {
-          return tightGap;
-        }
-        if (isToolSequenceItem(item) && belowItem.kind === "assistant_message") {
-          return looseGap;
-        }
-        if (isSameAssistantBlockGroup({ item, other: belowItem })) {
-          return assistantBlockGap;
-        }
-        return looseGap;
-      },
-      [assistantBlockGap, looseGap, tightGap],
-    );
-
     const setInlineDetailsExpanded = useCallback(
       (itemId: string, expanded: boolean) => {
         if (!streamRenderStrategy.shouldDisableParentScrollOnInlineDetailsExpansion()) {
@@ -418,11 +517,12 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             workspaceRoot={workspaceRoot}
             serverId={serverId}
             client={client}
+            toast={toast}
             spacing={spacing}
           />
         );
       },
-      [handleInlinePathPress, streamRenderStrategy, workspaceRoot, serverId, client],
+      [handleInlinePathPress, streamRenderStrategy, workspaceRoot, serverId, client, toast],
     );
 
     const renderThoughtItem = useCallback(
@@ -540,7 +640,13 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
             return <TodoListCard items={item.items} />;
 
           case "compaction":
-            return <CompactionMarker status={item.status} preTokens={item.preTokens} />;
+            return (
+              <CompactionMarker
+                status={item.status}
+                trigger={item.trigger}
+                preTokens={item.preTokens}
+              />
+            );
 
           default:
             return null;
@@ -549,6 +655,22 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [renderUserMessageItem, renderAssistantMessageItem, renderThoughtItem, renderToolCallItem],
     );
 
+    const bottomTurnFooterHost = useMemo(() => {
+      return resolveBottomTurnFooterHost({
+        agentStatus: agent.status,
+        history: baseRenderModel.history,
+        liveHead: baseRenderModel.segments.liveHead,
+        isInverted: streamRenderStrategy.getFlatListInverted(),
+        timingByAssistantId: baseRenderModel.turnTiming.byAssistantId,
+      });
+    }, [
+      agent.status,
+      baseRenderModel.history,
+      baseRenderModel.segments.liveHead,
+      baseRenderModel.turnTiming.byAssistantId,
+      streamRenderStrategy,
+    ]);
+
     const renderStreamItem = useCallback(
       (
         item: StreamItem,
@@ -557,45 +679,29 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
         seams: StreamItemBoundarySeams = {},
       ) => {
         const content = renderStreamItemContent(item, index, items, seams);
-        if (!content) {
-          return null;
-        }
-
         const nextItem = getStreamNeighborItem({
           strategy: streamRenderStrategy,
           items,
           index,
           relation: "below",
         });
-        const gapBelow = getGapBetween(item, nextItem ?? null);
-        const isEndOfAssistantTurn =
-          item.kind === "assistant_message" &&
-          (nextItem?.kind === "user_message" ||
-            (nextItem === undefined && agent.status !== "running"));
-        const isRunningAssistantTurnFooter =
-          item.kind === "assistant_message" && item.id === inlineWorkingIndicatorItemId;
-        let footer: ReactNode = null;
-        if (isRunningAssistantTurnFooter) {
-          footer = <InlineWorkingIndicatorSlot />;
-        } else if (isEndOfAssistantTurn) {
-          footer = (
-            <TurnCopyButtonSlot strategy={streamRenderStrategy} items={items} startIndex={index} />
-          );
-        }
-
-        return (
-          <StreamItemWrapper gapBelow={gapBelow}>
-            {content}
-            {footer}
-          </StreamItemWrapper>
-        );
+        return renderStreamItemWithTurnFooter({
+          content,
+          item,
+          nextItem,
+          items,
+          timing: baseRenderModel.turnTiming.byAssistantId,
+          index,
+          agentStatus: agent.status,
+          suppressTurnFooter: seams.suppressTurnFooter,
+          strategy: streamRenderStrategy,
+        });
       },
       [
-        getGapBetween,
-        renderStreamItemContent,
         agent.status,
+        baseRenderModel.turnTiming.byAssistantId,
+        renderStreamItemContent,
         streamRenderStrategy,
-        inlineWorkingIndicatorItemId,
       ],
     );
 
@@ -604,66 +710,56 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
       [pendingPermissions, agentId],
     );
 
-    const showAuxiliaryWorkingIndicator =
-      agent.status === "running" && inlineWorkingIndicatorItemId === null;
+    const showRunningTurnFooter = agent.status === "running";
     const pendingPermissionsNode = useMemo(
       () =>
-        pendingPermissionItems.length > 0 ? (
-          <View style={stylesheet.permissionsContainer}>
-            {pendingPermissionItems.map((permission) => (
-              <PermissionRequestCard key={permission.key} permission={permission} client={client} />
-            ))}
-          </View>
-        ) : null,
+        renderPendingPermissionsNode({
+          pendingPermissions: pendingPermissionItems,
+          client,
+        }),
       [client, pendingPermissionItems],
     );
-    const workingIndicatorNode = useMemo(
+    const turnFooterNode = useMemo(
       () =>
-        showAuxiliaryWorkingIndicator ? (
-          <View style={stylesheet.bottomBarWrapper} testID="stream-working-indicator-auxiliary">
-            <WorkingIndicator />
-          </View>
+        showRunningTurnFooter || bottomTurnFooterHost ? (
+          <TurnFooter
+            isRunning={showRunningTurnFooter}
+            inFlightTurnStartedAt={baseRenderModel.turnTiming.runningStartedAt}
+            host={bottomTurnFooterHost}
+            strategy={streamRenderStrategy}
+          />
         ) : null,
-      [showAuxiliaryWorkingIndicator],
+      [
+        showRunningTurnFooter,
+        baseRenderModel.turnTiming.runningStartedAt,
+        bottomTurnFooterHost,
+        streamRenderStrategy,
+      ],
     );
     const renderModel = useMemo<AgentStreamRenderModel>(() => {
       return {
         ...baseRenderModel,
         boundary: {
           ...baseRenderModel.boundary,
-          historyToHeadGap: getGapBetween(
+          historyToHeadGap: getGapBetweenStreamItems(
             baseRenderModel.history.at(-1) ?? null,
             baseRenderModel.segments.liveHead[0] ?? null,
           ),
         },
         auxiliary: {
           pendingPermissions: pendingPermissionsNode,
-          workingIndicator: workingIndicatorNode,
+          turnFooter: turnFooterNode,
         },
       };
-    }, [baseRenderModel, getGapBetween, pendingPermissionsNode, workingIndicatorNode]);
+    }, [baseRenderModel, pendingPermissionsNode, turnFooterNode]);
 
     const emptyStateStyle = useMemo(() => [stylesheet.emptyState, stylesheet.contentWrapper], []);
-    const listEmptyComponent = useMemo(() => {
-      if (
-        renderModel.boundary.hasVirtualizedHistory ||
-        renderModel.boundary.hasMountedHistory ||
-        renderModel.boundary.hasLiveHead ||
-        renderModel.auxiliary.pendingPermissions ||
-        renderModel.auxiliary.workingIndicator
-      ) {
-        return null;
-      }
-
-      return (
-        <View style={emptyStateStyle}>
-          <Text style={stylesheet.emptyStateText}>Start chatting with this agent...</Text>
-        </View>
-      );
-    }, [renderModel, emptyStateStyle]);
+    const listEmptyComponent = useMemo(
+      () => renderListEmptyComponent({ renderModel, emptyStateStyle }),
+      [renderModel, emptyStateStyle],
+    );
 
     const historyItems = renderModel.history;
-    const _liveHeadItems = renderModel.segments.liveHead;
     const { boundary, auxiliary } = renderModel;
     const lastHistoryItem = historyItems.at(-1) ?? null;
     const firstLiveHeadItem = renderModel.segments.liveHead[0] ?? null;
@@ -677,17 +773,24 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     }, [historyItems]);
 
     const renderHistoryRow = useCallback(
-      (item: StreamItem) => {
-        const historyIndex = historyIndexById.get(item.id);
-        if (historyIndex === undefined) {
-          return null;
-        }
-        const seamBelowItem = item.id === lastHistoryItem?.id ? firstLiveHeadItem : null;
-        return renderStreamItem(item, historyIndex, historyItems, {
-          belowItem: seamBelowItem,
-        });
-      },
-      [firstLiveHeadItem, historyIndexById, historyItems, lastHistoryItem?.id, renderStreamItem],
+      (item: StreamItem) =>
+        renderHistoryStreamItem({
+          item,
+          historyIndexById,
+          historyItems,
+          lastHistoryItem,
+          firstLiveHeadItem,
+          bottomTurnFooterHost,
+          renderStreamItem,
+        }),
+      [
+        bottomTurnFooterHost,
+        firstLiveHeadItem,
+        historyIndexById,
+        historyItems,
+        lastHistoryItem,
+        renderStreamItem,
+      ],
     );
 
     const renderHistoryVirtualizedRow = useCallback<
@@ -699,32 +802,22 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
     );
     const renderLiveHeadRow = useCallback<StreamSegmentRenderers["renderLiveHeadRow"]>(
       (item, index, items) =>
-        renderStreamItem(item, index, items, {
-          aboveItem: index === 0 ? lastHistoryItem : null,
+        renderLiveHeadStreamItem({
+          item,
+          index,
+          items,
+          lastHistoryItem,
+          bottomTurnFooterHost,
+          renderStreamItem,
         }),
-      [lastHistoryItem, renderStreamItem],
+      [bottomTurnFooterHost, lastHistoryItem, renderStreamItem],
     );
-    const liveAuxiliaryHeaderStyle = useMemo(() => {
-      let headerPadding: { paddingBottom: number } | { paddingTop: number } | null;
-      if (!boundary.hasLiveHead) headerPadding = null;
-      else if (streamRenderStrategy.getFlatListInverted())
-        headerPadding = { paddingBottom: looseGap };
-      else headerPadding = { paddingTop: looseGap };
-      return [stylesheet.listHeaderContent, headerPadding];
-    }, [boundary.hasLiveHead, streamRenderStrategy, looseGap]);
     const renderLiveAuxiliary = useCallback<StreamSegmentRenderers["renderLiveAuxiliary"]>(() => {
-      if (!auxiliary.pendingPermissions && !auxiliary.workingIndicator) {
-        return null;
-      }
-      return (
-        <View style={stylesheet.contentWrapper}>
-          <View style={liveAuxiliaryHeaderStyle}>
-            {auxiliary.pendingPermissions}
-            {auxiliary.workingIndicator}
-          </View>
-        </View>
-      );
-    }, [auxiliary.pendingPermissions, auxiliary.workingIndicator, liveAuxiliaryHeaderStyle]);
+      return renderLiveAuxiliaryNode({
+        pendingPermissions: auxiliary.pendingPermissions,
+        turnFooter: auxiliary.turnFooter,
+      });
+    }, [auxiliary.pendingPermissions, auxiliary.turnFooter]);
 
     const renderers = useMemo<StreamSegmentRenderers>(
       () => ({
@@ -796,106 +889,6 @@ const AgentStreamViewComponent = forwardRef<AgentStreamViewHandle, AgentStreamVi
 export const AgentStreamView = memo(AgentStreamViewComponent);
 AgentStreamView.displayName = "AgentStreamView";
 
-function WorkingIndicator({ variant = "auxiliary" }: { variant?: "auxiliary" | "inline" }) {
-  const progress = useSharedValue(0);
-
-  useEffect(() => {
-    progress.value = 0;
-    progress.value = withRepeat(
-      withTiming(1, {
-        duration: WORKING_INDICATOR_CYCLE_MS,
-        easing: Easing.linear,
-      }),
-      -1,
-      false,
-    );
-
-    return () => {
-      cancelAnimation(progress);
-      progress.value = 0;
-    };
-  }, [progress]);
-
-  const translateDistance = -2;
-  const dotOneStyle = useAnimatedStyle(() => {
-    const strength = getWorkingIndicatorDotStrength(progress.value, WORKING_INDICATOR_OFFSETS[0]);
-    return {
-      opacity: 0.3 + strength * 0.7,
-      transform: [{ translateY: strength * translateDistance }],
-    };
-  });
-
-  const dotTwoStyle = useAnimatedStyle(() => {
-    const strength = getWorkingIndicatorDotStrength(progress.value, WORKING_INDICATOR_OFFSETS[1]);
-    return {
-      opacity: 0.3 + strength * 0.7,
-      transform: [{ translateY: strength * translateDistance }],
-    };
-  });
-
-  const dotThreeStyle = useAnimatedStyle(() => {
-    const strength = getWorkingIndicatorDotStrength(progress.value, WORKING_INDICATOR_OFFSETS[2]);
-    return {
-      opacity: 0.3 + strength * 0.7,
-      transform: [{ translateY: strength * translateDistance }],
-    };
-  });
-
-  const dotOneCombinedStyle = useMemo(() => [stylesheet.workingDot, dotOneStyle], [dotOneStyle]);
-  const dotTwoCombinedStyle = useMemo(() => [stylesheet.workingDot, dotTwoStyle], [dotTwoStyle]);
-  const dotThreeCombinedStyle = useMemo(
-    () => [stylesheet.workingDot, dotThreeStyle],
-    [dotThreeStyle],
-  );
-
-  const containerStyle =
-    variant === "inline"
-      ? stylesheet.inlineWorkingIndicatorFrame
-      : stylesheet.workingIndicatorBubble;
-
-  return (
-    <View style={containerStyle}>
-      <View style={stylesheet.workingDotsRow}>
-        <Animated.View style={dotOneCombinedStyle} />
-        <Animated.View style={dotTwoCombinedStyle} />
-        <Animated.View style={dotThreeCombinedStyle} />
-      </View>
-    </View>
-  );
-}
-
-function InlineWorkingIndicatorSlot() {
-  return (
-    <View style={stylesheet.inlineTurnFooter} testID="turn-working-indicator">
-      <WorkingIndicator variant="inline" />
-    </View>
-  );
-}
-
-// Permission Request Card Component
-type TurnContentStrategy = Parameters<
-  typeof collectAssistantTurnContentForStreamRenderStrategy
->[0]["strategy"];
-
-interface TurnCopyButtonSlotProps {
-  strategy: TurnContentStrategy;
-  items: StreamItem[];
-  startIndex: number;
-}
-
-function TurnCopyButtonSlot({ strategy, items, startIndex }: TurnCopyButtonSlotProps) {
-  const getContent = useCallback(
-    () =>
-      collectAssistantTurnContentForStreamRenderStrategy({
-        strategy,
-        items,
-        startIndex,
-      }),
-    [strategy, items, startIndex],
-  );
-  return <TurnCopyButton getContent={getContent} />;
-}
-
 interface ToolCallSlotProps extends Omit<
   ComponentProps<typeof ToolCall>,
   "onInlineDetailsExpandedChange"
@@ -1192,6 +1185,7 @@ const stylesheet = StyleSheet.create((theme) => ({
     width: "100%",
     maxWidth: MAX_CONTENT_WIDTH,
     alignSelf: "center",
+    paddingHorizontal: theme.spacing[2],
   },
   listContentContainer: {
     paddingVertical: 0,
@@ -1212,6 +1206,7 @@ const stylesheet = StyleSheet.create((theme) => ({
     width: "100%",
     maxWidth: MAX_CONTENT_WIDTH,
     alignSelf: "center",
+    paddingHorizontal: theme.spacing[2],
   },
   emptyState: {
     flex: 1,
@@ -1225,51 +1220,6 @@ const stylesheet = StyleSheet.create((theme) => ({
   listHeaderContent: {
     gap: theme.spacing[3],
   },
-  bottomBarWrapper: {
-    flexDirection: "row",
-    alignItems: "center",
-    justifyContent: "flex-start",
-    marginTop: theme.spacing[4],
-    paddingLeft: 3,
-    paddingRight: 3,
-    paddingTop: theme.spacing[3],
-    paddingBottom: theme.spacing[2],
-    gap: theme.spacing[2],
-  },
-  inlineTurnFooter: {
-    alignSelf: "flex-start",
-    marginTop: theme.spacing[2],
-    padding: theme.spacing[2],
-    paddingTop: 0,
-  },
-  inlineWorkingIndicatorFrame: {
-    height: 18,
-    alignItems: "center",
-    justifyContent: "center",
-  },
-  workingIndicatorBubble: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: theme.spacing[2],
-    paddingHorizontal: 0,
-    paddingVertical: theme.spacing[1],
-    paddingLeft: theme.spacing[2],
-    borderRadius: theme.borderRadius.full,
-    backgroundColor: "transparent",
-    borderWidth: 0,
-    alignSelf: "flex-start",
-  },
-  workingDotsRow: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: theme.spacing[1],
-  },
-  workingDot: {
-    width: 6,
-    height: 6,
-    borderRadius: 3,
-    backgroundColor: theme.colors.foregroundMuted,
-  },
   syncingIndicator: {
     flexDirection: "row",
     alignItems: "center",

packages/app/src/components/composer-actions.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import type { AgentAttachment, GitHubSearchItem } from "@server/shared/messages";
 import type {
   AttachmentMetadata,
@@ -19,6 +19,7 @@ import {
   removeComposerAttachmentAtIndex,
   sendQueuedComposerMessageNow,
   toggleGithubAttachment,
+  toggleGithubAttachmentFromPicker,
   type AgentStreamWriter,
   type AttachmentPersister,
   type ComposerCancelClient,
@@ -696,6 +697,36 @@ describe("toggleGithubAttachment", () => {
   });
 });
 
+describe("toggleGithubAttachmentFromPicker", () => {
+  it("marks an existing GitHub item as removed when picker toggle removes it", () => {
+    const markGithubAttachmentRemoved = vi.fn();
+    const attachment: UserComposerAttachment = { kind: "github_pr", item: prItem };
+
+    const next = toggleGithubAttachmentFromPicker({
+      current: [attachment],
+      item: prItem,
+      markGithubAttachmentRemoved,
+    });
+
+    expect(next).toEqual([]);
+    expect(markGithubAttachmentRemoved).toHaveBeenCalledTimes(1);
+    expect(markGithubAttachmentRemoved).toHaveBeenCalledWith(attachment);
+  });
+
+  it("does not mark a GitHub item removed when picker toggle adds it", () => {
+    const markGithubAttachmentRemoved = vi.fn();
+
+    const next = toggleGithubAttachmentFromPicker({
+      current: [],
+      item: issueItem,
+      markGithubAttachmentRemoved,
+    });
+
+    expect(next).toEqual([{ kind: "github_issue", item: issueItem }]);
+    expect(markGithubAttachmentRemoved).not.toHaveBeenCalled();
+  });
+});
+
 describe("findGithubItemByOption / isAttachmentSelectedForGithubItem", () => {
   it("locates items via their composite kind:number id", () => {
     expect(findGithubItemByOption([issueItem, prItem], "issue:101")).toBe(issueItem);

packages/app/src/components/composer-actions.ts

@@ -305,6 +305,29 @@ export function toggleGithubAttachment(
   return [...current, buildGithubAttachment(item)];
 }
 
+interface ToggleGithubAttachmentFromPickerInput {
+  current: UserComposerAttachment[];
+  item: GitHubSearchItem;
+  markGithubAttachmentRemoved: (attachment: UserComposerAttachment) => void;
+}
+
+export function toggleGithubAttachmentFromPicker({
+  current,
+  item,
+  markGithubAttachmentRemoved,
+}: ToggleGithubAttachmentFromPickerInput): UserComposerAttachment[] {
+  const existingAttachment = current.find(
+    (attachment) =>
+      attachment.kind !== "image" &&
+      attachment.item.kind === item.kind &&
+      attachment.item.number === item.number,
+  );
+  if (existingAttachment) {
+    markGithubAttachmentRemoved(existingAttachment);
+  }
+  return toggleGithubAttachment(current, item);
+}
+
 export function findGithubItemByOption(
   items: readonly GitHubSearchItem[],
   optionId: string,

packages/app/src/components/composer-height-mirror.web.ts

@@ -98,13 +98,19 @@ export function useComposerHeightMirror({
 
   useLayoutEffect(() => {
     measure();
-  }, [value, measure]);
+  }, [maxHeight, minHeight, value, measure]);
 
   useEffect(() => {
     const source = textareaRef.current;
     if (!source || !(source instanceof HTMLElement)) return;
     if (typeof ResizeObserver === "undefined") return;
-    const observer = new ResizeObserver(() => measure());
+    let previousWidth = source.clientWidth;
+    const observer = new ResizeObserver(() => {
+      const nextWidth = source.clientWidth;
+      if (Math.abs(nextWidth - previousWidth) < 1) return;
+      previousWidth = nextWidth;
+      measure();
+    });
     observer.observe(source);
     return () => observer.disconnect();
   }, [textareaRef, measure]);

packages/app/src/components/composer.tsx

@@ -21,7 +21,6 @@ import {
   Paperclip,
 } from "lucide-react-native";
 import Animated from "react-native-reanimated";
-import { useQuery } from "@tanstack/react-query";
 import { FOOTER_HEIGHT, MAX_CONTENT_WIDTH } from "@/constants/layout";
 import {
   AgentStatusBar,
@@ -53,7 +52,7 @@ import {
   queueComposerMessage,
   removeComposerAttachmentAtIndex,
   sendQueuedComposerMessageNow,
-  toggleGithubAttachment,
+  toggleGithubAttachmentFromPicker,
   type AgentStreamWriter,
   type QueueWriter,
   type QueuedComposerMessage,
@@ -97,6 +96,10 @@ import { AttachmentPill } from "@/components/attachment-pill";
 import { AttachmentLightbox } from "@/components/attachment-lightbox";
 import { openExternalUrl } from "@/utils/open-external-url";
 import { useIsDictationReady } from "@/hooks/use-is-dictation-ready";
+import { useGithubSearchQuery } from "@/git/use-github-search-query";
+import { useCheckoutStatusQuery } from "@/git/use-status-query";
+import { useComposerGithubAutoAttach } from "./use-composer-github-auto-attach";
+import { resolveClientSlashCommand, type ClientSlashCommand } from "@/client-slash-commands";
 
 type QueuedMessage = QueuedComposerMessage;
 
@@ -137,6 +140,20 @@ function resolveMessagePlaceholder(isDesktopWebBreakpoint: boolean): string {
   return isDesktopWebBreakpoint ? DESKTOP_MESSAGE_PLACEHOLDER : MOBILE_MESSAGE_PLACEHOLDER;
 }
 
+function resolveGithubSearchEnabled(
+  isGithubPickerOpen: boolean,
+  isConnected: boolean,
+  cwd: string,
+): boolean {
+  return isGithubPickerOpen && isConnected && cwd.trim().length > 0;
+}
+
+function resolveCheckoutRemoteUrl(
+  checkoutStatus: ReturnType<typeof useCheckoutStatusQuery>["status"],
+): string | null {
+  return checkoutStatus?.remoteUrl ?? null;
+}
+
 function buildCancelButtonStyle(isConnected: boolean, isCancellingAgent: boolean): object[] {
   const disabled = !isConnected || isCancellingAgent ? styles.buttonDisabled : undefined;
   return [styles.cancelButton, disabled].filter((value): value is object => Boolean(value));
@@ -164,31 +181,6 @@ function buildAgentStateSelector(serverId: string, agentId: string) {
   };
 }
 
-interface BuildGithubSearchQueryOptionsArgs {
-  serverId: string;
-  cwd: string;
-  githubSearchQueryTrimmed: string;
-  isGithubPickerOpen: boolean;
-  isConnected: boolean;
-  client: ReturnType<typeof useHostRuntimeClient>;
-}
-
-function buildGithubSearchQueryOptions(args: BuildGithubSearchQueryOptionsArgs) {
-  const { serverId, cwd, githubSearchQueryTrimmed, isGithubPickerOpen, isConnected, client } = args;
-  const hasClient = Boolean(client);
-  const cwdIsSet = cwd.trim().length > 0;
-  const enabled = isGithubPickerOpen && isConnected && hasClient && cwdIsSet;
-  return {
-    queryKey: ["composer-github-search", serverId, cwd, githubSearchQueryTrimmed],
-    queryFn: async () => {
-      if (!client) throw new Error("Host is not connected");
-      return client.searchGitHub({ cwd, query: githubSearchQueryTrimmed, limit: 20 });
-    },
-    enabled,
-    staleTime: 30_000,
-  };
-}
-
 function renderContextWindowMeterSlot(
   contextWindowMaxTokens: number | null,
   contextWindowUsedTokens: number | null,
@@ -616,6 +608,7 @@ interface ComposerProps {
   serverId: string;
   isPaneFocused: boolean;
   onSubmitMessage?: (payload: MessagePayload) => Promise<void>;
+  onClientSlashCommand?: (command: ClientSlashCommand) => Promise<void>;
   /** When true, the submit button is enabled even without text or images (e.g. external attachment selected). */
   hasExternalContent?: boolean;
   /** When true, the composer can submit even with no text or attachments. */
@@ -816,6 +809,7 @@ export function Composer({
   serverId,
   isPaneFocused,
   onSubmitMessage,
+  onClientSlashCommand,
   hasExternalContent = false,
   allowEmptySubmit = false,
   submitButtonAccessibilityLabel,
@@ -890,6 +884,17 @@ export function Composer({
     onOpenWorkspaceAttachment,
   });
   const setSelectedAttachments = onChangeAttachments;
+  const checkoutStatusQuery = useCheckoutStatusQuery({ serverId, cwd });
+  const githubAutoAttach = useComposerGithubAutoAttach({
+    text: userInput,
+    remoteUrl: resolveCheckoutRemoteUrl(checkoutStatusQuery.status),
+    attachments,
+    client,
+    isConnected,
+    serverId,
+    cwd,
+    setAttachments: setSelectedAttachments,
+  });
   const [cursorIndex, setCursorIndex] = useState(0);
   const [isProcessing, setIsProcessing] = useState(false);
   const [isCancellingAgent, setIsCancellingAgent] = useState(false);
@@ -905,6 +910,41 @@ export function Composer({
     `message-input:${serverId}:${agentId}:${Math.random().toString(36).slice(2)}`,
   );
 
+  const runClientSlashCommand = useCallback(
+    (command: ClientSlashCommand): boolean => {
+      if (command.execution !== "immediate" || !onClientSlashCommand) {
+        return false;
+      }
+
+      if (blurOnSubmit) {
+        messageInputRef.current?.blur();
+      }
+      clearDraft("sent");
+      setUserInput("");
+      setSelectedAttachments([]);
+      resetSuppression();
+      setSendError(null);
+      setIsProcessing(true);
+      void onClientSlashCommand(command)
+        .catch((error) => {
+          console.error("[Composer] Failed to run client slash command:", error);
+          setSendError(error instanceof Error ? error.message : String(error));
+        })
+        .finally(() => {
+          setIsProcessing(false);
+        });
+      return true;
+    },
+    [
+      blurOnSubmit,
+      clearDraft,
+      onClientSlashCommand,
+      resetSuppression,
+      setSelectedAttachments,
+      setUserInput,
+    ],
+  );
+
   const autocomplete = useAgentAutocomplete({
     userInput,
     cursorIndex,
@@ -912,6 +952,8 @@ export function Composer({
     serverId,
     agentId,
     draftConfig: commandDraftConfig,
+    canExecuteClientSlashCommand: buildOutgoingAttachments(attachments).length === 0,
+    onClientSlashCommand: runClientSlashCommand,
     onAutocompleteApplied: () => {
       messageInputRef.current?.focus();
     },
@@ -1107,16 +1149,27 @@ export function Composer({
 
   const handleSubmit = useCallback(
     (payload: MessagePayload) => {
+      const outgoingAttachments = buildOutgoingAttachments(attachments);
+      const clientSlashCommand = resolveClientSlashCommand({
+        text: payload.text,
+        hasAttachments: outgoingAttachments.length > 0,
+      });
+      if (clientSlashCommand && runClientSlashCommand(clientSlashCommand)) {
+        return;
+      }
+
       if (blurOnSubmit) {
         messageInputRef.current?.blur();
       }
-      void sendMessageWithContent(
-        payload.text,
-        buildOutgoingAttachments(attachments),
-        payload.forceSend,
-      );
+      void sendMessageWithContent(payload.text, outgoingAttachments, payload.forceSend);
     },
-    [attachments, blurOnSubmit, buildOutgoingAttachments, sendMessageWithContent],
+    [
+      attachments,
+      blurOnSubmit,
+      buildOutgoingAttachments,
+      runClientSlashCommand,
+      sendMessageWithContent,
+    ],
   );
 
   const handlePickImage = useCallback(async () => {
@@ -1135,6 +1188,7 @@ export function Composer({
 
   const handleRemoveAttachment = useCallback(
     (index: number) => {
+      githubAutoAttach.markGithubAttachmentRemoved(selectedAttachments[index]);
       const didRemoveWorkspaceAttachment = removeAttachment({
         selectedAttachments,
         index,
@@ -1146,7 +1200,7 @@ export function Composer({
         removeComposerAttachmentAtIndex({ attachments: prev, index, deleteAttachments }),
       );
     },
-    [removeAttachment, selectedAttachments, setSelectedAttachments],
+    [githubAutoAttach, removeAttachment, selectedAttachments, setSelectedAttachments],
   );
 
   const handleOpenAttachment = useCallback(
@@ -1277,18 +1331,25 @@ export function Composer({
 
   const handleQueue = useCallback(
     (payload: MessagePayload) => {
-      queueMessage(payload.text, buildOutgoingAttachments(attachments));
+      const outgoingAttachments = buildOutgoingAttachments(attachments);
+      const clientSlashCommand = resolveClientSlashCommand({
+        text: payload.text,
+        hasAttachments: outgoingAttachments.length > 0,
+      });
+      if (clientSlashCommand && runClientSlashCommand(clientSlashCommand)) {
+        return;
+      }
+      queueMessage(payload.text, outgoingAttachments);
     },
-    [attachments, buildOutgoingAttachments, queueMessage],
+    [attachments, buildOutgoingAttachments, queueMessage, runClientSlashCommand],
   );
 
   const hasSendableContent = userInput.trim().length > 0 || selectedAttachments.length > 0;
 
   // Handle keyboard navigation for command autocomplete.
   const handleCommandKeyPress = useCallback(
-    (event: { key: string; preventDefault: () => void }) => {
-      return autocompleteOnKeyPressRef.current(event);
-    },
+    (event: { key: string; preventDefault: () => void }) =>
+      autocompleteOnKeyPressRef.current(event),
     [],
   );
 
@@ -1376,16 +1437,13 @@ export function Composer({
   );
 
   const githubSearchQueryTrimmed = githubSearchQuery.trim();
-  const githubSearchResultsQuery = useQuery(
-    buildGithubSearchQueryOptions({
-      serverId,
-      cwd,
-      githubSearchQueryTrimmed,
-      isGithubPickerOpen,
-      isConnected,
-      client,
-    }),
-  );
+  const githubSearchResultsQuery = useGithubSearchQuery({
+    client,
+    serverId,
+    cwd,
+    query: githubSearchQueryTrimmed,
+    enabled: resolveGithubSearchEnabled(isGithubPickerOpen, isConnected, cwd),
+  });
 
   const githubSearchItemsRaw = githubSearchResultsQuery.data?.items;
   const githubSearchItems = useMemo(() => githubSearchItemsRaw ?? [], [githubSearchItemsRaw]);
@@ -1423,11 +1481,22 @@ export function Composer({
 
   const handleToggleGithubItem = useCallback(
     (item: GitHubSearchItem) => {
-      setSelectedAttachments((current) => toggleGithubAttachment(current, item));
+      const nextAttachments = toggleGithubAttachmentFromPicker({
+        current: attachments,
+        item,
+        markGithubAttachmentRemoved: githubAutoAttach.markGithubAttachmentRemoved,
+      });
+      setSelectedAttachments(nextAttachments);
       setIsGithubPickerOpen(false);
       setGithubSearchQuery("");
     },
-    [setSelectedAttachments, setGithubSearchQuery, setIsGithubPickerOpen],
+    [
+      attachments,
+      githubAutoAttach,
+      setSelectedAttachments,
+      setGithubSearchQuery,
+      setIsGithubPickerOpen,
+    ],
   );
 
   const leftContent = useMemo(

packages/app/src/components/draggable-list.web.test.tsx

@@ -13,6 +13,9 @@ interface DndContextProps {
 }
 
 let latestDndContextProps: DndContextProps | null = null;
+const dndKitMocks = vi.hoisted(() => ({
+  useSensor: vi.fn(() => ({})),
+}));
 
 vi.mock("@dnd-kit/core", () => ({
   DndContext: ({ children, ...props }: React.PropsWithChildren<DndContextProps>) => {
@@ -22,7 +25,7 @@ vi.mock("@dnd-kit/core", () => ({
   closestCenter: vi.fn(),
   KeyboardSensor: vi.fn(),
   PointerSensor: vi.fn(),
-  useSensor: vi.fn(() => ({})),
+  useSensor: dndKitMocks.useSensor,
   useSensors: vi.fn(() => []),
 }));
 
@@ -104,7 +107,7 @@ function renderItem({ item, isActive }: { item: string; isActive: boolean }) {
   );
 }
 
-function renderList(): void {
+function renderList({ useDragHandle = false }: { useDragHandle?: boolean } = {}): void {
   act(() => {
     root?.render(
       <DraggableList
@@ -113,6 +116,7 @@ function renderList(): void {
         onDragEnd={vi.fn()}
         renderItem={renderItem}
         scrollEnabled={false}
+        useDragHandle={useDragHandle}
       />,
     );
   });
@@ -125,6 +129,28 @@ function getItemActiveState(item: string): string | null {
 }
 
 describe("DraggableList web", () => {
+  it("uses distance activation for default draggable rows", () => {
+    renderList();
+
+    expect(dndKitMocks.useSensor).toHaveBeenCalledWith(
+      expect.any(Function),
+      expect.objectContaining({
+        activationConstraint: { distance: 6 },
+      }),
+    );
+  });
+
+  it("requires a held pointer before activating handle-based drags", () => {
+    renderList({ useDragHandle: true });
+
+    expect(dndKitMocks.useSensor).toHaveBeenCalledWith(
+      expect.any(Function),
+      expect.objectContaining({
+        activationConstraint: { delay: 250, tolerance: 8 },
+      }),
+    );
+  });
+
   it("clears active drag state when a drag is cancelled", () => {
     renderList();
 

packages/app/src/components/draggable-list.web.tsx

@@ -30,6 +30,8 @@ const restrictToVerticalAxis: Modifier = ({ transform }) => ({
 });
 
 const DND_MODIFIERS = [restrictToVerticalAxis];
+const DEFAULT_POINTER_ACTIVATION_CONSTRAINT = { distance: 6 };
+const HANDLE_POINTER_ACTIVATION_CONSTRAINT = { delay: 250, tolerance: 8 };
 
 interface SortableItemProps<T> {
   id: string;
@@ -143,12 +145,13 @@ export function DraggableList<T>({
   const scrollbar = useWebScrollViewScrollbar(scrollViewRef, {
     enabled: showCustomScrollbar,
   });
+  const pointerActivationConstraint = useDragHandle
+    ? HANDLE_POINTER_ACTIVATION_CONSTRAINT
+    : DEFAULT_POINTER_ACTIVATION_CONSTRAINT;
 
   const sensors = useSensors(
     useSensor(PointerSensor, {
-      activationConstraint: {
-        distance: 6,
-      },
+      activationConstraint: pointerActivationConstraint,
     }),
     useSensor(KeyboardSensor, {
       coordinateGetter: sortableKeyboardCoordinates,

packages/app/src/components/file-pane.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo, useRef } from "react";
+import React, { useEffect, useMemo, useRef } from "react";
 import { useQuery } from "@tanstack/react-query";
 import type { FileReadResult } from "@server/client/daemon-client";
 import Markdown, { MarkdownIt } from "react-native-markdown-display";
@@ -15,13 +15,8 @@ import { Fonts } from "@/constants/theme";
 import { useSessionStore, type ExplorerFile } from "@/stores/session-store";
 import { useWebScrollViewScrollbar } from "@/components/use-web-scrollbar";
 import { useWebScrollbarStyle } from "@/hooks/use-web-scrollbar-style";
-import {
-  highlightCode,
-  darkHighlightColors,
-  lightHighlightColors,
-  type HighlightToken,
-  type HighlightStyle,
-} from "@getpaseo/highlight";
+import { highlightCode, type HighlightToken } from "@getpaseo/highlight";
+import { syntaxTokenStyleFor } from "@/styles/syntax-token-styles";
 import { lineNumberGutterWidth } from "@/components/code-insets";
 import { isRenderedMarkdownFile } from "@/components/file-pane-render-mode";
 import { isWeb } from "@/constants/platform";
@@ -31,13 +26,13 @@ import { useAttachmentPreviewUrl } from "@/attachments/use-attachment-preview-ur
 import { persistAttachmentFromBytes } from "@/attachments/service";
 import { createPreviewAttachmentId, getFileNameFromPath } from "@/attachments/utils";
 import { explorerFileFromReadResult } from "@/file-explorer/read-result";
+import type { WorkspaceFileLocation } from "@/workspace/file-open";
 
 interface CodeLineProps {
   tokens: HighlightToken[];
   lineNumber: number;
   gutterWidth: number;
-  colorMap: Record<HighlightStyle, string>;
-  baseColor: string;
+  highlighted: boolean;
 }
 
 interface FilePreviewBodyProps {
@@ -45,7 +40,7 @@ interface FilePreviewBodyProps {
   isLoading: boolean;
   showDesktopWebScrollbar: boolean;
   isMobile: boolean;
-  filePath: string;
+  location: WorkspaceFileLocation;
   imagePreviewUri: string | null;
 }
 
@@ -57,6 +52,11 @@ function trimNonEmpty(value: string | null | undefined): string | null {
   return trimmed.length > 0 ? trimmed : null;
 }
 
+interface FileLineSelection {
+  lineStart: number;
+  lineEnd: number;
+}
+
 function formatFileSize({ size }: { size: number }): string {
   if (size < 1024) {
     return `${size} B`;
@@ -99,36 +99,46 @@ async function createFilePanePreview(file: FileReadResult | null): Promise<{
   };
 }
 
+function clampLineSelection(input: {
+  lineStart?: number;
+  lineEnd?: number;
+  lineCount: number;
+}): FileLineSelection | null {
+  if (!input.lineStart || input.lineStart <= 0 || input.lineCount <= 0) {
+    return null;
+  }
+  const lineStart = Math.min(Math.floor(input.lineStart), input.lineCount);
+  const rawLineEnd =
+    input.lineEnd && input.lineEnd >= input.lineStart ? input.lineEnd : input.lineStart;
+  const lineEnd = Math.min(Math.floor(rawLineEnd), input.lineCount);
+  return { lineStart, lineEnd: Math.max(lineStart, lineEnd) };
+}
+
 const CodeLine = React.memo(function CodeLine({
   tokens,
   lineNumber,
   gutterWidth,
-  colorMap,
-  baseColor,
+  highlighted,
 }: CodeLineProps) {
   const gutterStyle = useMemo(() => [codeLineStyles.gutter, { width: gutterWidth }], [gutterWidth]);
-  const gutterTextStyle = useMemo(
-    () => [codeLineStyles.gutterText, { color: baseColor }],
-    [baseColor],
+  const lineStyle = useMemo(
+    () => [codeLineStyles.line, highlighted && codeLineStyles.highlightedLine],
+    [highlighted],
   );
   const keyedTokens = useMemo(
     () => tokens.map((token, index) => ({ key: `${index}-${token.text}`, token })),
     [tokens],
   );
   return (
-    <View style={codeLineStyles.line}>
+    <View style={lineStyle}>
       <View style={gutterStyle}>
-        <Text numberOfLines={1} style={gutterTextStyle}>
+        <Text numberOfLines={1} style={codeLineStyles.gutterText}>
           {String(lineNumber)}
         </Text>
       </View>
       <Text selectable style={codeLineStyles.lineText}>
         {keyedTokens.map(({ key, token }) => (
-          <CodeLineToken
-            key={key}
-            color={token.style ? (colorMap[token.style] ?? baseColor) : baseColor}
-            text={token.text}
-          />
+          <CodeLineToken key={key} token={token} />
         ))}
       </Text>
     </View>
@@ -136,25 +146,27 @@ const CodeLine = React.memo(function CodeLine({
 });
 
 interface CodeLineTokenProps {
-  color: string;
-  text: string;
+  token: HighlightToken;
 }
 
-function CodeLineToken({ color, text }: CodeLineTokenProps) {
-  const style = useMemo(() => ({ color }), [color]);
-  return <Text style={style}>{text}</Text>;
+function CodeLineToken({ token }: CodeLineTokenProps) {
+  return <Text style={syntaxTokenStyleFor(token.style)}>{token.text}</Text>;
 }
 
 const codeLineStyles = StyleSheet.create((theme) => ({
   line: {
     flexDirection: "row",
   },
+  highlightedLine: {
+    backgroundColor: theme.colors.accentBorder,
+  },
   gutter: {
     alignItems: "flex-end",
     paddingRight: theme.spacing[3],
     flexShrink: 0,
   },
   gutterText: {
+    color: theme.colors.foreground,
     fontFamily: Fonts.mono,
     fontSize: theme.fontSize.sm,
     lineHeight: theme.fontSize.sm * 1.45,
@@ -174,16 +186,15 @@ function FilePreviewBody({
   isLoading,
   showDesktopWebScrollbar,
   isMobile,
-  filePath,
+  location,
   imagePreviewUri,
 }: FilePreviewBodyProps) {
   const { theme } = useUnistyles();
-  const isDark = theme.colorScheme === "dark";
-  const colorMap = isDark ? darkHighlightColors : lightHighlightColors;
-  const baseColor = isDark ? "#c9d1d9" : "#24292f";
+  const filePath = location.path;
   const markdownStyles = useMemo(() => createMarkdownStyles(theme), [theme]);
   const markdownParser = useMemo(() => MarkdownIt({ typographer: true, linkify: true }), []);
-  const isMarkdownFile = preview?.kind === "text" && isRenderedMarkdownFile(filePath);
+  const isMarkdownFile =
+    preview?.kind === "text" && isRenderedMarkdownFile(filePath) && !location.lineStart;
 
   const previewScrollRef = useRef<RNScrollView>(null);
   const webScrollbarStyle = useWebScrollbarStyle();
@@ -203,12 +214,36 @@ function FilePreviewBody({
     if (!highlightedLines) return 0;
     return lineNumberGutterWidth(highlightedLines.length, theme.fontSize.sm);
   }, [highlightedLines, theme.fontSize.sm]);
+  const lineHeight = theme.fontSize.sm * 1.45;
+  const lineSelection = useMemo(() => {
+    if (!highlightedLines) {
+      return null;
+    }
+    return clampLineSelection({
+      lineStart: location.lineStart,
+      lineEnd: location.lineEnd,
+      lineCount: highlightedLines.length,
+    });
+  }, [highlightedLines, location.lineEnd, location.lineStart]);
 
   const imageSource = useMemo(
     () => (imagePreviewUri ? { uri: imagePreviewUri } : null),
     [imagePreviewUri],
   );
 
+  useEffect(() => {
+    if (!lineSelection) {
+      return;
+    }
+    const timeout = setTimeout(() => {
+      previewScrollRef.current?.scrollTo({
+        y: Math.max(0, (lineSelection.lineStart - 1) * lineHeight),
+        animated: false,
+      });
+    }, 0);
+    return () => clearTimeout(timeout);
+  }, [lineHeight, lineSelection]);
+
   if (isLoading && !preview) {
     return (
       <View style={styles.centerState}>
@@ -263,8 +298,11 @@ function FilePreviewBody({
             tokens={tokens}
             lineNumber={lineNumber}
             gutterWidth={gutterWidth}
-            colorMap={colorMap}
-            baseColor={baseColor}
+            highlighted={
+              Boolean(lineSelection) &&
+              lineNumber >= (lineSelection?.lineStart ?? 0) &&
+              lineNumber <= (lineSelection?.lineEnd ?? 0)
+            }
           />
         ))}
       </View>
@@ -344,18 +382,18 @@ function FilePreviewBody({
 export function FilePane({
   serverId,
   workspaceRoot,
-  filePath,
+  location,
 }: {
   serverId: string;
   workspaceRoot: string;
-  filePath: string;
+  location: WorkspaceFileLocation;
 }) {
   const isMobile = useIsCompactFormFactor();
   const showDesktopWebScrollbar = isWeb && !isMobile;
 
   const client = useSessionStore((state) => state.sessions[serverId]?.client ?? null);
   const normalizedWorkspaceRoot = useMemo(() => workspaceRoot.trim(), [workspaceRoot]);
-  const normalizedFilePath = useMemo(() => trimNonEmpty(filePath), [filePath]);
+  const normalizedFilePath = useMemo(() => trimNonEmpty(location.path), [location.path]);
 
   const query = useQuery({
     queryKey: ["workspaceFile", serverId, normalizedWorkspaceRoot, normalizedFilePath],
@@ -398,7 +436,7 @@ export function FilePane({
         isLoading={query.isFetching}
         showDesktopWebScrollbar={showDesktopWebScrollbar}
         isMobile={isMobile}
-        filePath={filePath}
+        location={location}
         imagePreviewUri={imagePreviewUri}
       />
     </View>

packages/app/src/components/highlighted-code-block.tsx

@@ -0,0 +1,269 @@
+import React, { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import {
+  Pressable,
+  Text,
+  View,
+  type StyleProp,
+  type TextStyle,
+  type ViewStyle,
+} from "react-native";
+import { StyleSheet } from "react-native-unistyles";
+import * as Clipboard from "expo-clipboard";
+import { Check, Copy } from "lucide-react-native";
+import { highlightCode, type HighlightToken } from "@getpaseo/highlight";
+import { isNative, isWeb } from "@/constants/platform";
+import { useIsCompactFormFactor } from "@/constants/layout";
+import { syntaxTokenStyleFor } from "@/styles/syntax-token-styles";
+
+interface HighlightedCodeBlockProps {
+  code: string;
+  language: string | null | undefined;
+  inheritedStyles: TextStyle;
+  textStyle: TextStyle;
+}
+
+// Fence info strings ("```ts", "```typescript", "```ts {1,3}") map to the
+// extension-based parser table in @getpaseo/highlight. Aliases here only
+// cover names that don't already match an extension key in parsers.ts.
+const LANGUAGE_ALIASES: Record<string, string> = {
+  typescript: "ts",
+  javascript: "js",
+  python: "py",
+  rust: "rs",
+  golang: "go",
+  "c++": "cpp",
+  objc: "m",
+  "objective-c": "m",
+  markdown: "md",
+  elixir: "ex",
+};
+
+function fenceLanguageToExtension(info: string | null | undefined): string | null {
+  if (!info) return null;
+  const first = info.trim().split(/\s+/)[0]?.toLowerCase();
+  if (!first) return null;
+  const normalized = first.replace(/^\./, "");
+  return LANGUAGE_ALIASES[normalized] ?? normalized;
+}
+
+// Cross-instance cache for tokenized code blocks. Tokenization is
+// theme-independent (colors are applied at render time), so the key is just
+// (language, code). Bounded by entry count — 200 is generous for a chat
+// transcript, code blocks rarely repeat beyond a handful of distinct shapes.
+class LRUCache<K, V> {
+  private readonly map = new Map<K, V>();
+  constructor(private readonly max: number) {}
+
+  get(key: K): V | undefined {
+    const value = this.map.get(key);
+    if (value === undefined) return undefined;
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+
+  set(key: K, value: V): void {
+    if (this.map.has(key)) this.map.delete(key);
+    else if (this.map.size >= this.max) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== undefined) this.map.delete(oldest);
+    }
+    this.map.set(key, value);
+  }
+}
+
+const tokenizationCache = new LRUCache<string, KeyedLine[]>(200);
+
+export const HighlightedCodeBlock = React.memo(function HighlightedCodeBlock({
+  code,
+  language,
+  inheritedStyles,
+  textStyle,
+}: HighlightedCodeBlockProps) {
+  // Box styles (bg / padding / border / radius / margin) go on the wrapper View
+  // so the absolute copy button positions relative to the visible code area,
+  // not to a parent that includes the Text's own marginVertical.
+  const { containerStyle, innerTextStyle } = useMemo(
+    () => splitFenceStyle(inheritedStyles, textStyle),
+    [inheritedStyles, textStyle],
+  );
+
+  const keyedLines = useMemo<KeyedLine[] | null>(() => {
+    const ext = fenceLanguageToExtension(language);
+    if (!ext) return null;
+    const cacheKey = `${ext}:${code}`;
+    const cached = tokenizationCache.get(cacheKey);
+    if (cached) return cached;
+    let tokenizedLines: HighlightToken[][];
+    try {
+      tokenizedLines = highlightCode(code, `x.${ext}`);
+    } catch {
+      return null;
+    }
+    const result = tokenizedLines.map(toKeyedLine);
+    tokenizationCache.set(cacheKey, result);
+    return result;
+  }, [code, language]);
+
+  const isCompact = useIsCompactFormFactor();
+  const [isHovered, setIsHovered] = useState(false);
+  const handlePointerEnter = useCallback(() => setIsHovered(true), []);
+  const handlePointerLeave = useCallback(() => setIsHovered(false), []);
+  const controlsVisible = isHovered || isNative || isCompact;
+  const getCode = useCallback(() => code, [code]);
+
+  return (
+    <View
+      style={containerStyle}
+      onPointerEnter={handlePointerEnter}
+      onPointerLeave={handlePointerLeave}
+    >
+      {keyedLines ? (
+        <Text style={innerTextStyle}>
+          {keyedLines.map((line, lineIndex) => (
+            <React.Fragment key={line.key}>
+              {lineIndex > 0 ? "\n" : null}
+              {line.tokens.map(({ key, token }) => (
+                <TokenSpan key={key} token={token} />
+              ))}
+            </React.Fragment>
+          ))}
+        </Text>
+      ) : (
+        <Text style={innerTextStyle}>{code}</Text>
+      )}
+      <CopyButton getCode={getCode} visible={controlsVisible} />
+    </View>
+  );
+});
+
+interface KeyedToken {
+  key: string;
+  token: HighlightToken;
+}
+
+interface KeyedLine {
+  key: string;
+  tokens: KeyedToken[];
+}
+
+function toKeyedLine(tokens: HighlightToken[], lineIndex: number): KeyedLine {
+  return {
+    key: `line-${lineIndex}`,
+    tokens: tokens.map((token, tokenIndex) => ({
+      key: `${lineIndex}-${tokenIndex}`,
+      token,
+    })),
+  };
+}
+
+interface TokenSpanProps {
+  token: HighlightToken;
+}
+
+const TokenSpan = React.memo(function TokenSpan({ token }: TokenSpanProps) {
+  if (!token.style) return token.text;
+  return <Text style={syntaxTokenStyleFor(token.style)}>{token.text}</Text>;
+});
+
+interface SplitStyles {
+  containerStyle: StyleProp<ViewStyle>;
+  innerTextStyle: StyleProp<TextStyle>;
+}
+
+const CONTAINER_BASE: ViewStyle = { position: "relative" };
+const WEB_SELECTABLE: TextStyle = isWeb ? ({ userSelect: "text" } as TextStyle) : {};
+
+function splitFenceStyle(inheritedStyles: TextStyle, textStyle: TextStyle): SplitStyles {
+  const { fontFamily, fontSize, color, ...box } = textStyle;
+  const textOnly: TextStyle = { ...WEB_SELECTABLE };
+  if (fontFamily !== undefined) textOnly.fontFamily = fontFamily;
+  if (fontSize !== undefined) textOnly.fontSize = fontSize;
+  if (color !== undefined) textOnly.color = color;
+  return {
+    containerStyle: [box as ViewStyle, CONTAINER_BASE],
+    innerTextStyle: [inheritedStyles, textOnly],
+  };
+}
+
+interface CopyButtonProps {
+  getCode: () => string;
+  visible: boolean;
+}
+
+const COPIED_RESET_MS = 1500;
+
+const CopyButton = React.memo(function CopyButton({ getCode, visible }: CopyButtonProps) {
+  const [copied, setCopied] = useState(false);
+  const resetRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(
+    () => () => {
+      if (resetRef.current) clearTimeout(resetRef.current);
+    },
+    [],
+  );
+
+  const handlePress = useCallback(async () => {
+    const content = getCode();
+    if (!content) return;
+    await Clipboard.setStringAsync(content);
+    setCopied(true);
+    if (resetRef.current) clearTimeout(resetRef.current);
+    resetRef.current = setTimeout(() => {
+      setCopied(false);
+      resetRef.current = null;
+    }, COPIED_RESET_MS);
+  }, [getCode]);
+
+  const visibilityStyle = visible
+    ? copyButtonStyles.containerVisible
+    : copyButtonStyles.containerHidden;
+  const wrapperStyle = useMemo(
+    () => [copyButtonStyles.container, visibilityStyle],
+    [visibilityStyle],
+  );
+
+  return (
+    <Pressable
+      onPress={handlePress}
+      style={wrapperStyle}
+      pointerEvents={visible ? "auto" : "none"}
+      accessibilityRole="button"
+      accessibilityLabel={copied ? "Copied" : "Copy code"}
+      hitSlop={8}
+    >
+      {({ hovered }) => {
+        const iconColor = hovered
+          ? copyButtonStyles.iconHoveredColor.color
+          : copyButtonStyles.iconColor.color;
+        return copied ? (
+          <Check size={14} color={iconColor} />
+        ) : (
+          <Copy size={14} color={iconColor} />
+        );
+      }}
+    </Pressable>
+  );
+});
+
+const copyButtonStyles = StyleSheet.create((theme) => ({
+  container: {
+    position: "absolute",
+    top: theme.spacing[2],
+    right: theme.spacing[2],
+    padding: theme.spacing[1],
+  },
+  containerVisible: {
+    opacity: 1,
+  },
+  containerHidden: {
+    opacity: 0,
+  },
+  iconColor: {
+    color: theme.colors.foregroundMuted,
+  },
+  iconHoveredColor: {
+    color: theme.colors.foreground,
+  },
+}));

packages/app/src/components/left-sidebar.tsx

@@ -1,5 +1,5 @@
 import { router, usePathname } from "expo-router";
-import { FolderPlus, MessagesSquare, Settings } from "lucide-react-native";
+import { FolderPlus, MessagesSquare, Settings, X } from "lucide-react-native";
 import {
   type Dispatch,
   memo,
@@ -472,6 +472,7 @@ function SidebarFooter({
         searchable={false}
         title="Switch host"
         searchPlaceholder="Search hosts..."
+        desktopMinWidth={280}
         open={isHostPickerOpen}
         onOpenChange={setIsHostPickerOpen}
         anchorRef={hostTriggerRef}
@@ -679,6 +680,25 @@ function MobileSidebar({
               isActive={isSessionsActive}
               testID="sidebar-sessions"
             />
+            <Pressable
+              style={styles.mobileCloseButton}
+              onPress={closeToAgent}
+              testID="sidebar-close"
+              nativeID="sidebar-close"
+              accessible
+              accessibilityRole="button"
+              accessibilityLabel="Close sidebar"
+              hitSlop={8}
+            >
+              {({ hovered, pressed }) => (
+                <X
+                  size={theme.iconSize.md}
+                  color={
+                    hovered || pressed ? theme.colors.foreground : theme.colors.foregroundMuted
+                  }
+                />
+              )}
+            </Pressable>
 
             {isInitialLoad ? (
               <SidebarAgentListSkeleton />
@@ -888,6 +908,18 @@ const styles = StyleSheet.create((theme) => ({
     flex: 1,
     minHeight: 0,
   },
+  mobileCloseButton: {
+    position: "absolute",
+    top: theme.spacing[3],
+    right: theme.spacing[4],
+    zIndex: 2,
+    width: 32,
+    height: 32,
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: theme.borderRadius.lg,
+    backgroundColor: theme.colors.surfaceSidebar,
+  },
   desktopSidebarBorder: {
     borderRightWidth: 1,
     borderRightColor: theme.colors.border,

packages/app/src/components/message-compaction-label.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest";
+
+import { getCompactionMarkerLabel } from "./message-compaction-label";
+
+describe("getCompactionMarkerLabel", () => {
+  it("renders loading, automatic, manual, tokenized, and fallback labels", () => {
+    expect(getCompactionMarkerLabel({ status: "loading" })).toBe("Compacting...");
+    expect(getCompactionMarkerLabel({ status: "completed", trigger: "auto" })).toBe(
+      "Context automatically compacted",
+    );
+    expect(getCompactionMarkerLabel({ status: "completed", trigger: "manual" })).toBe(
+      "Context manually compacted",
+    );
+    expect(getCompactionMarkerLabel({ status: "completed", preTokens: 12_345 })).toBe(
+      "Context compacted (12K tokens)",
+    );
+    expect(getCompactionMarkerLabel({ status: "completed" })).toBe("Context compacted");
+  });
+});

packages/app/src/components/message-compaction-label.ts

@@ -0,0 +1,17 @@
+export interface CompactionMarkerLabelInput {
+  status: "loading" | "completed";
+  trigger?: "auto" | "manual";
+  preTokens?: number;
+}
+
+export function getCompactionMarkerLabel({
+  status,
+  trigger,
+  preTokens,
+}: CompactionMarkerLabelInput): string {
+  if (status === "loading") return "Compacting...";
+  if (trigger === "auto") return "Context automatically compacted";
+  if (trigger === "manual") return "Context manually compacted";
+  if (preTokens) return `Context compacted (${Math.round(preTokens / 1000)}K tokens)`;
+  return "Context compacted";
+}

packages/app/src/components/message-input.tsx

@@ -3,6 +3,7 @@ import {
   Text,
   TextInput,
   ActivityIndicator,
+  useWindowDimensions,
   NativeSyntheticEvent,
   TextInputContentSizeChangeEventData,
   TextInputKeyPressEventData,
@@ -47,11 +48,13 @@ import {
 } from "@/components/ui/dropdown-menu";
 import { useWebElementScrollbar } from "@/components/use-web-scrollbar";
 import { useShortcutKeys } from "@/hooks/use-shortcut-keys";
+import { useIosHardwareKeyboardSubmit } from "@/hooks/use-ios-hardware-keyboard-submit";
 import { formatShortcut } from "@/utils/format-shortcut";
 import { getShortcutOs } from "@/utils/shortcut-platform";
 import type { MessageInputKeyboardActionKind } from "@/keyboard/actions";
 import { isImeComposingKeyboardEvent } from "@/utils/keyboard-ime";
 import { isWeb } from "@/constants/platform";
+import { useIsCompactFormFactor } from "@/constants/layout";
 import { useComposerHeightMirror } from "./composer-height-mirror";
 import { computeCanStartDictation } from "./message-input-state";
 
@@ -142,7 +145,8 @@ export interface MessageInputRef {
 
 const MIN_INPUT_HEIGHT_MOBILE = 30;
 const MIN_INPUT_HEIGHT_DESKTOP = 46;
-const MAX_INPUT_HEIGHT = 160;
+const DEFAULT_MAX_INPUT_HEIGHT = 160;
+const MAX_INPUT_VIEWPORT_RATIO = 0.5;
 const MIN_INPUT_HEIGHT = isWeb ? MIN_INPUT_HEIGHT_DESKTOP : MIN_INPUT_HEIGHT_MOBILE;
 
 type WebTextInputKeyPressEvent = NativeSyntheticEvent<
@@ -364,6 +368,7 @@ function resolveSendTooltipLabel(input: {
 
 interface DesktopKeyPressContext {
   onKeyPressCallback: ((event: { key: string; preventDefault: () => void }) => boolean) | undefined;
+  submitOnEnter: boolean;
   isAgentRunning: boolean;
   onQueue: ((payload: MessagePayload) => void) | undefined;
   isSubmitDisabled: boolean;
@@ -390,6 +395,7 @@ function handleDesktopKeyPressImpl(
   const { shiftKey, metaKey, ctrlKey } = event.nativeEvent;
 
   if (event.nativeEvent.key !== "Enter") return;
+  if (!ctx.submitOnEnter) return;
   if (shiftKey) return;
 
   if ((metaKey || ctrlKey) && ctx.isAgentRunning && ctx.onQueue) {
@@ -979,17 +985,22 @@ function computeIsDictationStartEnabled(
   return (isReadyForDictation ?? isConnected) && !disabled;
 }
 
-function computeTextInputHeightStyle(inputHeight: number) {
+function resolveMaxInputHeight(windowHeight: number): number {
+  if (!Number.isFinite(windowHeight) || windowHeight <= 0) return DEFAULT_MAX_INPUT_HEIGHT;
+  return Math.max(DEFAULT_MAX_INPUT_HEIGHT, Math.floor(windowHeight * MAX_INPUT_VIEWPORT_RATIO));
+}
+
+function computeTextInputHeightStyle(inputHeight: number, maxInputHeight: number) {
   if (isWeb) {
     return {
       height: inputHeight,
       minHeight: MIN_INPUT_HEIGHT,
-      maxHeight: MAX_INPUT_HEIGHT,
+      maxHeight: maxInputHeight,
     };
   }
   return {
     minHeight: MIN_INPUT_HEIGHT,
-    maxHeight: MAX_INPUT_HEIGHT,
+    maxHeight: maxInputHeight,
   };
 }
 
@@ -1186,6 +1197,9 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       inputWrapperStyle,
       attachmentSlot,
     } = resolveMessageInputProps(props);
+    const isCompact = useIsCompactFormFactor();
+    const { height: windowHeight } = useWindowDimensions();
+    const maxInputHeight = resolveMaxInputHeight(windowHeight);
     const buttonIconSize = isWeb ? ICON_SIZE.md : ICON_SIZE.lg;
     const toast = useToast();
     const voice = useVoiceOptional();
@@ -1450,7 +1464,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
     const handleSendMessage = useCallback(
       () =>
         sendMessageImpl({
-          value,
+          value: valueRef.current,
           attachments,
           hasExternalContent,
           allowEmptySubmit,
@@ -1461,7 +1475,6 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
         }),
       [
         allowEmptySubmit,
-        value,
         attachments,
         cwd,
         onSubmit,
@@ -1474,14 +1487,14 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
     const handleQueueMessage = useCallback(
       () =>
         queueMessageImpl({
-          value,
+          value: valueRef.current,
           attachments,
           cwd,
           onQueue,
           onChangeText,
           onMinimizeHeight: minimizeInputHeight,
         }),
-      [value, attachments, cwd, onQueue, onChangeText, minimizeInputHeight],
+      [attachments, cwd, onQueue, onChangeText, minimizeInputHeight],
     );
 
     const handleDefaultSendAction = useCallback(() => {
@@ -1518,7 +1531,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
     }, [getWebTextArea]);
 
     const inputScrollbar = useWebElementScrollbar(webTextareaRef, {
-      enabled: isWeb && inputHeight >= MAX_INPUT_HEIGHT,
+      enabled: isWeb,
     });
 
     usePasteImagesEffect({
@@ -1532,20 +1545,24 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
 
     const setBoundedInputHeight = useCallback(
       (nextHeight: number) => {
-        const bounded = Math.max(MIN_INPUT_HEIGHT, Math.min(MAX_INPUT_HEIGHT, nextHeight));
+        const bounded = Math.max(MIN_INPUT_HEIGHT, Math.min(maxInputHeight, nextHeight));
         if (Math.abs(inputHeightRef.current - bounded) < 1) return;
         inputHeightRef.current = bounded;
         setInputHeight(bounded);
         onHeightChange?.(bounded);
       },
-      [onHeightChange],
+      [maxInputHeight, onHeightChange],
     );
 
+    useEffect(() => {
+      setBoundedInputHeight(inputHeightRef.current);
+    }, [setBoundedInputHeight]);
+
     useComposerHeightMirror({
       value,
       textareaRef: webTextareaRef,
       minHeight: MIN_INPUT_HEIGHT,
-      maxHeight: MAX_INPUT_HEIGHT,
+      maxHeight: maxInputHeight,
       onHeight: setBoundedInputHeight,
     });
 
@@ -1566,12 +1583,14 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       [onSelectionChangeCallback],
     );
 
-    const shouldHandleDesktopSubmit = isWeb;
+    const shouldHandleWebKeyPress = isWeb;
+    const shouldSubmitOnEnter = isWeb && !isCompact;
 
     function handleDesktopKeyPress(event: WebTextInputKeyPressEvent) {
-      if (!shouldHandleDesktopSubmit) return;
+      if (!shouldHandleWebKeyPress) return;
       handleDesktopKeyPressImpl(event, {
         onKeyPressCallback,
+        submitOnEnter: shouldSubmitOnEnter,
         isAgentRunning,
         onQueue,
         isSubmitDisabled,
@@ -1598,6 +1617,10 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
         defaultSendBehavior,
         isAgentRunning,
       });
+    useIosHardwareKeyboardSubmit({
+      isEnabled: isInputFocused && !isSendButtonDisabled,
+      onSubmit: handleDefaultSendAction,
+    });
     const submitAccessibilityLabel = resolveSubmitAccessibilityLabel({
       submitButtonAccessibilityLabel,
       canPressLoadingButton,
@@ -1618,6 +1641,7 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
 
     const handleInputChange = useCallback(
       (nextValue: string) => {
+        valueRef.current = nextValue;
         onChangeText(nextValue);
       },
       [onChangeText],
@@ -1663,8 +1687,8 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
       [inputWrapperStyle, inputAnimatedStyle],
     );
     const textInputStyle = useMemo(
-      () => [styles.textInput, computeTextInputHeightStyle(inputHeight)],
-      [inputHeight],
+      () => [styles.textInput, computeTextInputHeightStyle(inputHeight, maxInputHeight)],
+      [inputHeight, maxInputHeight],
     );
     const sendButtonCombinedStyle = useMemo(
       () => [styles.sendButton, isSendButtonDisabled && styles.buttonDisabled],
@@ -1716,10 +1740,10 @@ export const MessageInput = forwardRef<MessageInputRef, MessageInputProps>(
               onBlur={handleInputBlur}
               style={textInputStyle}
               multiline
-              scrollEnabled={isWeb ? inputHeight >= MAX_INPUT_HEIGHT : true}
+              scrollEnabled={isWeb ? inputHeight >= maxInputHeight : true}
               onContentSizeChange={handleContentSizeChange}
               editable={!isDictating && !isRealtimeVoiceForCurrentAgent && !disabled}
-              onKeyPress={shouldHandleDesktopSubmit ? handleDesktopKeyPress : undefined}
+              onKeyPress={shouldHandleWebKeyPress ? handleDesktopKeyPress : undefined}
               onSelectionChange={handleSelectionChange}
               autoFocus={isWeb && autoFocus}
             />

packages/app/src/components/sidebar-workspace-list.tsx

@@ -106,6 +106,7 @@ import {
   requireWorkspaceExecutionDirectory,
   resolveWorkspaceExecutionDirectory,
 } from "@/utils/workspace-execution";
+import { confirmRiskyWorktreeArchive } from "@/git/worktree-archive-warning";
 import {
   archiveWorkspaceOptimistically,
   archiveWorkspacesOptimistically,
@@ -593,7 +594,7 @@ function ProjectKebabMenu({
       <DropdownMenuTrigger
         hitSlop={8}
         style={projectKebabStyle}
-        accessibilityRole="button"
+        accessibilityRole={platformIsWeb ? undefined : "button"}
         accessibilityLabel="Project actions"
         testID={`sidebar-project-kebab-${projectKey}`}
       >
@@ -724,7 +725,7 @@ function WorkspaceKebabMenu({
       <DropdownMenuTrigger
         hitSlop={8}
         style={workspaceKebabStyle}
-        accessibilityRole="button"
+        accessibilityRole={platformIsWeb ? undefined : "button"}
         accessibilityLabel="Workspace actions"
         testID={`sidebar-workspace-kebab-${workspaceKey}`}
       >
@@ -894,7 +895,7 @@ function NewWorktreeButton({
             style={pressableStyle}
             onPress={handlePress}
             disabled={loading}
-            accessibilityRole="button"
+            accessibilityRole={platformIsWeb ? undefined : "button"}
             accessibilityLabel={`Create a new workspace for ${displayName}`}
             testID={testID}
           >
@@ -1172,10 +1173,13 @@ function ProjectHeaderRow({
       return;
     }
     router.navigate(
-      buildHostNewWorkspaceRoute(serverId, project.iconWorkingDir, { displayName }) as Href,
+      buildHostNewWorkspaceRoute(serverId, project.iconWorkingDir, {
+        displayName,
+        projectId: project.projectKey,
+      }) as Href,
     );
     onWorkspacePress?.();
-  }, [displayName, onWorkspacePress, project.iconWorkingDir, serverId]);
+  }, [displayName, onWorkspacePress, project.iconWorkingDir, project.projectKey, serverId]);
   const _mergeWorkspaces = useSessionStore((state) => state.mergeWorkspaces);
   const _toast = useToast();
 
@@ -1183,6 +1187,12 @@ function ProjectHeaderRow({
     drag,
     menuController,
   });
+  const {
+    role: _dragRole,
+    tabIndex: _dragTabIndex,
+    "aria-roledescription": _dragRoleDescription,
+    ...dragAttributes
+  } = dragHandleProps?.attributes ?? {};
 
   const handlePress = useCallback(() => {
     if (interaction.didLongPressRef.current) {
@@ -1246,7 +1256,7 @@ function ProjectHeaderRow({
   if (menuController) {
     return (
       <View
-        {...dragHandleProps?.attributes}
+        {...dragAttributes}
         {...dragHandleProps?.listeners}
         ref={dragHandleProps?.setActivatorNodeRef as unknown as Ref<View>}
         onPointerEnter={handlePointerEnter}
@@ -1254,6 +1264,7 @@ function ProjectHeaderRow({
       >
         <ContextMenuTrigger
           enabledOnMobile={false}
+          accessibilityRole="button"
           style={projectRowStyle}
           onPressIn={interaction.handlePressIn}
           onTouchMove={interaction.handleTouchMove}
@@ -1269,13 +1280,14 @@ function ProjectHeaderRow({
 
   return (
     <View
-      {...dragHandleProps?.attributes}
+      {...dragAttributes}
       {...dragHandleProps?.listeners}
       ref={dragHandleProps?.setActivatorNodeRef as unknown as Ref<View>}
       onPointerEnter={handlePointerEnter}
       onPointerLeave={handlePointerLeave}
     >
       <Pressable
+        accessibilityRole="button"
         style={projectRowStyle}
         onPressIn={interaction.handlePressIn}
         onTouchMove={interaction.handleTouchMove}
@@ -1324,6 +1336,12 @@ function WorkspaceRowInner({
     drag,
     menuController,
   });
+  const {
+    role: _dragRole,
+    tabIndex: _dragTabIndex,
+    "aria-roledescription": _dragRoleDescription,
+    ...dragAttributes
+  } = dragHandleProps?.attributes ?? {};
 
   const handlePress = useCallback(() => {
     if (interaction.didLongPressRef.current) {
@@ -1365,7 +1383,7 @@ function WorkspaceRowInner({
   return (
     <WorkspaceHoverCard workspace={workspace} prHint={prHint} isDragging={isDragging}>
       <View
-        {...dragHandleProps?.attributes}
+        {...dragAttributes}
         {...dragHandleProps?.listeners}
         ref={dragHandleProps?.setActivatorNodeRef as unknown as Ref<View>}
         style={styles.workspaceRowContainer}
@@ -1474,92 +1492,93 @@ function WorkspaceRowWithMenu({
     });
   }, [activeWorkspaceSelection, workspace.serverId, workspace.workspaceId]);
 
-  const handleArchiveWorktree = useCallback(() => {
+  const archiveWorktreeAfterConfirmation = useCallback(async () => {
     if (isArchiving) {
       return;
     }
 
-    void (async () => {
-      const confirmed = await confirmDialog({
-        title: "Archive worktree?",
-        message: `Archive "${workspace.name}"?\n\nThe worktree will be removed from disk, terminals will be stopped, and agents inside will be archived.\n\nYour branch is still accessible if you committed.`,
-        confirmLabel: "Archive",
-        cancelLabel: "Cancel",
-        destructive: true,
+    const confirmed = await confirmRiskyWorktreeArchive({
+      worktreeName: workspace.name,
+      isDirty: workspace.archiveHasUncommittedChanges,
+      aheadOfOrigin: workspace.archiveUnpushedCommitCount,
+      diffStat: workspace.diffStat,
+    });
+
+    if (!confirmed) {
+      return;
+    }
+    let archiveDirectory: string;
+    try {
+      archiveDirectory = requireWorkspaceExecutionDirectory({
+        workspaceId: workspace.workspaceId,
+        workspaceDirectory: workspace.workspaceDirectory,
       });
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Workspace path not available");
+      return;
+    }
 
-      if (!confirmed) {
-        return;
-      }
-      let archiveDirectory: string;
-      try {
-        archiveDirectory = requireWorkspaceExecutionDirectory({
-          workspaceId: workspace.workspaceId,
-          workspaceDirectory: workspace.workspaceDirectory,
-        });
-      } catch (error) {
-        toast.error(error instanceof Error ? error.message : "Workspace path not available");
-        return;
-      }
+    if (!archiveDirectory) {
+      toast.error("Workspace path not available");
+      return;
+    }
 
-      if (!archiveDirectory) {
-        toast.error("Workspace path not available");
-        return;
-      }
+    redirectAfterArchive();
 
-      redirectAfterArchive();
-
-      void archiveWorktree({
-        serverId: workspace.serverId,
-        cwd: archiveDirectory,
-        worktreePath: archiveDirectory,
-      }).catch((error) => {
-        const message = error instanceof Error ? error.message : "Failed to archive worktree";
-        toast.error(message);
-      });
-    })();
+    void archiveWorktree({
+      serverId: workspace.serverId,
+      cwd: archiveDirectory,
+      worktreePath: archiveDirectory,
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : "Failed to archive worktree";
+      toast.error(message);
+    });
   }, [archiveWorktree, isArchiving, redirectAfterArchive, toast, workspace]);
 
-  const handleArchiveWorkspace = useCallback(() => {
+  const handleArchiveWorktree = useCallback(() => {
+    void archiveWorktreeAfterConfirmation();
+  }, [archiveWorktreeAfterConfirmation]);
+
+  const hideWorkspaceAfterConfirmation = useCallback(async () => {
     if (isArchivingWorkspace) {
       return;
     }
 
-    void (async () => {
-      const confirmed = await confirmDialog({
-        title: "Hide workspace?",
-        message: `Hide "${workspace.name}" from the sidebar?\n\nFiles on disk will not be changed.`,
-        confirmLabel: "Hide",
-        cancelLabel: "Cancel",
-        destructive: true,
+    const confirmed = await confirmDialog({
+      title: "Hide workspace?",
+      message: `Hide "${workspace.name}" from the sidebar?\n\nFiles on disk will not be changed.`,
+      confirmLabel: "Hide",
+      cancelLabel: "Cancel",
+      destructive: true,
+    });
+    if (!confirmed) {
+      return;
+    }
+
+    const client = getHostRuntimeStore().getClient(workspace.serverId);
+    if (!client) {
+      toast.error("Host is not connected");
+      return;
+    }
+
+    setIsArchivingWorkspace(true);
+    try {
+      await archiveWorkspaceOptimistically({
+        client,
+        workspace,
+        afterHide: redirectAfterArchive,
       });
-      if (!confirmed) {
-        return;
-      }
-
-      const client = getHostRuntimeStore().getClient(workspace.serverId);
-      if (!client) {
-        toast.error("Host is not connected");
-        return;
-      }
-
-      setIsArchivingWorkspace(true);
-      void (async () => {
-        try {
-          await archiveWorkspaceOptimistically({
-            client,
-            workspace,
-            afterHide: redirectAfterArchive,
-          });
-        } catch (error) {
-          toast.error(error instanceof Error ? error.message : "Failed to hide workspace");
-        } finally {
-          setIsArchivingWorkspace(false);
-        }
-      })();
-    })();
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Failed to hide workspace");
+    } finally {
+      setIsArchivingWorkspace(false);
+    }
   }, [isArchivingWorkspace, redirectAfterArchive, toast, workspace]);
 
+  const handleArchiveWorkspace = useCallback(() => {
+    void hideWorkspaceAfterConfirmation();
+  }, [hideWorkspaceAfterConfirmation]);
+
   const handleCopyPath = useCallback(() => {
     let copyTargetDirectory: string;
     try {
@@ -1589,7 +1608,7 @@ function WorkspaceRowWithMenu({
     priority: 0,
     handle: () => {
       if (isWorktree) {
-        handleArchiveWorktree();
+        void archiveWorktreeAfterConfirmation();
       } else {
         handleArchiveWorkspace();
       }

packages/app/src/components/split-container.tsx

@@ -67,7 +67,7 @@ import {
   type WorkspaceLayout,
 } from "@/stores/workspace-layout-store";
 import type { WorkspaceTab } from "@/stores/workspace-tabs-store";
-import { workspaceTabTargetsEqual } from "@/utils/workspace-tab-identity";
+import { workspaceTabTargetsEqual } from "@/workspace-tabs/identity";
 import { isNative } from "@/constants/platform";
 
 interface SplitContainerProps {

packages/app/src/components/terminal-emulator.tsx

@@ -17,6 +17,7 @@ import { useDOMImperativeHandle, type DOMImperativeFactory } from "expo/dom";
 import "@xterm/xterm/css/xterm.css";
 import type { ITheme } from "@xterm/xterm";
 import type { TerminalState } from "@server/shared/messages";
+import type { TerminalInputModeState } from "@server/shared/terminal-input-mode";
 import type { PendingTerminalModifiers } from "../utils/terminal-keys";
 import { TerminalEmulatorRuntime } from "../terminal/runtime/terminal-emulator-runtime";
 import type { TerminalRendererReadyChange } from "../utils/terminal-renderer-readiness";
@@ -115,6 +116,7 @@ interface TerminalEmulatorProps {
   streamKey: string;
   testId?: string;
   xtermTheme?: ITheme;
+  scrollbackLines: number;
   swipeGesturesEnabled?: boolean;
   onSwipeLeft?: () => void;
   onSwipeRight?: () => void;
@@ -129,6 +131,7 @@ interface TerminalEmulatorProps {
     meta: boolean;
   }) => Promise<void> | void;
   onPendingModifiersConsumed?: () => Promise<void> | void;
+  onInputModeChange?: (state: TerminalInputModeState) => Promise<void> | void;
   onRendererReadyChange?: (change: TerminalRendererReadyChange) => void;
   pendingModifiers?: PendingTerminalModifiers;
   focusRequestToken?: number;
@@ -186,6 +189,7 @@ export default function TerminalEmulator({
     foreground: "#e6e6e6",
     cursor: "#e6e6e6",
   },
+  scrollbackLines,
   swipeGesturesEnabled = false,
   onSwipeLeft,
   onSwipeRight,
@@ -194,6 +198,7 @@ export default function TerminalEmulator({
   onResize,
   onTerminalKey,
   onPendingModifiersConsumed,
+  onInputModeChange,
   onRendererReadyChange,
   pendingModifiers = { ctrl: false, shift: false, alt: false },
   focusRequestToken = 0,
@@ -203,6 +208,8 @@ export default function TerminalEmulator({
   const hostRef = useRef<HTMLDivElement | null>(null);
   const runtimeRef = useRef<TerminalEmulatorRuntime | null>(null);
   const mountedThemeRef = useRef<ITheme>(xtermTheme);
+  const scrollbackLinesRef = useRef(scrollbackLines);
+  scrollbackLinesRef.current = scrollbackLines;
   const viewportRef = useRef<HTMLElement | null>(null);
   const dragStartOffsetRef = useRef(0);
   const dragStartClientYRef = useRef(0);
@@ -219,12 +226,14 @@ export default function TerminalEmulator({
     onResize,
     onTerminalKey,
     onPendingModifiersConsumed,
+    onInputModeChange,
   });
   mountCallbacksRef.current = {
     onInput,
     onResize,
     onTerminalKey,
     onPendingModifiersConsumed,
+    onInputModeChange,
   };
   const initialSnapshotRef = useRef(initialSnapshot);
   initialSnapshotRef.current = initialSnapshot;
@@ -284,6 +293,10 @@ export default function TerminalEmulator({
     runtimeRef.current?.setTheme({ theme: nextTheme });
   }, [themeKey]);
 
+  useEffect(() => {
+    runtimeRef.current?.setScrollback({ lines: scrollbackLines });
+  }, [scrollbackLines]);
+
   useEffect(() => {
     ensureTerminalScrollbarStyle();
   }, []);
@@ -424,6 +437,7 @@ export default function TerminalEmulator({
       root,
       host,
       initialSnapshot: initialSnapshotRef.current,
+      scrollback: scrollbackLinesRef.current,
       theme: mountedThemeRef.current,
     });
     onRendererReadyChangeRef.current?.({ streamKey, isReady: true });
@@ -444,10 +458,11 @@ export default function TerminalEmulator({
         onResize,
         onTerminalKey,
         onPendingModifiersConsumed,
+        onInputModeChange,
         onOpenExternalUrl: openExternalUrl,
       },
     });
-  }, [onInput, onPendingModifiersConsumed, onResize, onTerminalKey]);
+  }, [onInput, onInputModeChange, onPendingModifiersConsumed, onResize, onTerminalKey]);
 
   useEffect(() => {
     runtimeRef.current?.setPendingModifiers({ pendingModifiers });

packages/app/src/components/terminal-pane.tsx

@@ -10,6 +10,7 @@ import {
 import Animated, { runOnJS, useAnimatedReaction } from "react-native-reanimated";
 import { StyleSheet, useUnistyles } from "react-native-unistyles";
 import { encodeTerminalKeyInput } from "@server/shared/terminal-key-input";
+import type { TerminalInputModeState } from "@server/shared/terminal-input-mode";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
 import { useKeyboardShiftStyle } from "@/hooks/use-keyboard-shift-style";
 import { useAppVisible } from "@/hooks/use-app-visible";
@@ -34,6 +35,7 @@ import {
   shouldShowTerminalLoadingOverlay,
   type TerminalRendererReadyChange,
 } from "@/utils/terminal-renderer-readiness";
+import { useAppSettings } from "@/hooks/use-settings";
 
 interface TerminalPaneProps {
   serverId: string;
@@ -156,6 +158,7 @@ export function TerminalPane({
 }: TerminalPaneProps) {
   const isAppVisible = useAppVisible();
   const { theme } = useUnistyles();
+  const { settings } = useAppSettings();
   const xtermTheme = useMemo(() => toXtermTheme(theme.colors.terminal), [theme]);
   const isMobile = useIsCompactFormFactor();
   const mobileView = usePanelStore((state) => state.mobileView);
@@ -188,6 +191,10 @@ export function TerminalPane({
   const [resizeRequestToken, setResizeRequestToken] = useState(0);
   const emulatorRef = useRef<TerminalEmulatorHandle>(null);
   const terminalIdRef = useRef<string>(terminalId);
+  const inputModeRef = useRef<TerminalInputModeState>({
+    kittyKeyboardFlags: 0,
+    win32InputMode: false,
+  });
   const pendingTerminalInputRef = useRef<PendingTerminalInput[]>([]);
   const keyboardRefitTimeoutsRef = useRef<Array<ReturnType<typeof setTimeout>>>([]);
   const lastAutoFocusKeyRef = useRef<string | null>(null);
@@ -195,6 +202,10 @@ export function TerminalPane({
 
   useEffect(() => {
     terminalIdRef.current = terminalId;
+    inputModeRef.current = {
+      kittyKeyboardFlags: 0,
+      win32InputMode: false,
+    };
   }, [terminalId]);
 
   const requestTerminalFocus = useCallback(() => {
@@ -413,7 +424,9 @@ export function TerminalPane({
         return true;
       }
 
-      const encoded = encodeTerminalKeyInput(entry.input);
+      const encoded = encodeTerminalKeyInput(entry.input, {
+        inputMode: inputModeRef.current,
+      });
       if (encoded.length === 0) {
         return true;
       }
@@ -595,6 +608,10 @@ export function TerminalPane({
     clearPendingModifiers();
   }, [clearPendingModifiers]);
 
+  const handleInputModeChange = useCallback((state: TerminalInputModeState) => {
+    inputModeRef.current = state;
+  }, []);
+
   const toggleModifier = useCallback(
     (modifier: keyof ModifierState) => {
       setModifiers((current) => ({ ...current, [modifier]: !current[modifier] }));
@@ -666,6 +683,7 @@ export function TerminalPane({
               streamKey={terminalStreamKey}
               testId="terminal-surface"
               xtermTheme={xtermTheme}
+              scrollbackLines={settings.terminalScrollbackLines}
               swipeGesturesEnabled={swipeGesturesEnabled}
               initialSnapshot={initialSnapshot}
               onRendererReadyChange={handleRendererReadyChange}
@@ -674,6 +692,7 @@ export function TerminalPane({
               onInput={handleTerminalData}
               onResize={handleTerminalResize}
               onTerminalKey={handleTerminalKey}
+              onInputModeChange={handleInputModeChange}
               onPendingModifiersConsumed={handlePendingModifiersConsumed}
               pendingModifiers={modifiers}
               focusRequestToken={focusRequestToken}

packages/app/src/components/use-composer-github-auto-attach.test.tsx

@@ -0,0 +1,213 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { act, renderHook } from "@testing-library/react";
+import React, { type ReactNode } from "react";
+import { useState } from "react";
+import { describe, expect, it, vi } from "vitest";
+import type { UserComposerAttachment } from "@/attachments/types";
+import type { GitHubSearchClient } from "@/git/use-github-search-query";
+import type { GitHubSearchItem, GitHubSearchResponse } from "@server/shared/messages";
+import { useComposerGithubAutoAttach } from "./use-composer-github-auto-attach";
+
+type GitHubSearchPayload = GitHubSearchResponse["payload"];
+
+const remoteUrl = "git@github.com:acme/paseo.git";
+const cwd = "/repo";
+
+const pr101: GitHubSearchItem = {
+  kind: "pr",
+  number: 101,
+  title: "Attach PR",
+  url: "https://github.com/acme/paseo/pull/101",
+  state: "open",
+  body: null,
+  labels: [],
+  baseRefName: "main",
+  headRefName: "feature",
+};
+
+const issue202: GitHubSearchItem = {
+  kind: "issue",
+  number: 202,
+  title: "Attach issue",
+  url: "https://github.com/acme/paseo/issues/202",
+  state: "open",
+  body: null,
+  labels: [],
+  baseRefName: null,
+  headRefName: null,
+};
+
+interface SearchCall {
+  cwd: string;
+  query: string;
+  limit?: number;
+}
+
+interface HarnessInput {
+  initialAttachments?: UserComposerAttachment[];
+  initialText?: string;
+  remote?: string | null;
+}
+
+function githubPayload(items: GitHubSearchItem[], requestId: string): GitHubSearchPayload {
+  return {
+    items,
+    githubFeaturesEnabled: true,
+    error: null,
+    requestId,
+  };
+}
+
+function createSearchClient(
+  items: GitHubSearchItem[],
+): GitHubSearchClient & { calls: SearchCall[] } {
+  const calls: SearchCall[] = [];
+  return {
+    calls,
+    async searchGitHub(options) {
+      calls.push(options);
+      return githubPayload(items, `search-${options.query}`);
+    },
+  };
+}
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: {
+      queries: {
+        retry: false,
+      },
+    },
+  });
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>;
+  };
+}
+
+function useHarness(client: GitHubSearchClient, input: HarnessInput = {}) {
+  const [text, setText] = useState(input.initialText ?? "");
+  const [attachments, setAttachments] = useState<UserComposerAttachment[]>(
+    input.initialAttachments ?? [],
+  );
+  const autoAttach = useComposerGithubAutoAttach({
+    text,
+    remoteUrl: input.remote ?? remoteUrl,
+    attachments,
+    client,
+    isConnected: true,
+    serverId: "server-1",
+    cwd,
+    setAttachments,
+  });
+
+  return {
+    text,
+    setText,
+    attachments,
+    setAttachments,
+    markGithubAttachmentRemoved: autoAttach.markGithubAttachmentRemoved,
+  };
+}
+
+async function flushDebounce() {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(300);
+    await Promise.resolve();
+  });
+}
+
+describe("useComposerGithubAutoAttach", () => {
+  it("adds a matching pasted GitHub PR URL as a composer attachment", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText("Please review https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([{ kind: "github_pr", item: pr101 }]);
+    expect(client.calls).toEqual([{ cwd, query: "101", limit: 20 }]);
+    vi.useRealTimers();
+  });
+
+  it("ignores URLs that do not match the current remote", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText("Other repo https://github.com/other/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([]);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("does not add a second pill when the ref is already attached", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const initialAttachments: UserComposerAttachment[] = [{ kind: "github_pr", item: pr101 }];
+    const { result } = renderHook(() => useHarness(client, { initialAttachments }), {
+      wrapper: createWrapper(),
+    });
+
+    act(() => {
+      result.current.setText("Already here https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual(initialAttachments);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("does not re-add a GitHub ref removed earlier in the same composer session", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101]);
+    const initialAttachments: UserComposerAttachment[] = [{ kind: "github_pr", item: pr101 }];
+    const { result } = renderHook(() => useHarness(client, { initialAttachments }), {
+      wrapper: createWrapper(),
+    });
+
+    act(() => {
+      result.current.markGithubAttachmentRemoved(initialAttachments[0]);
+      result.current.setAttachments([]);
+      result.current.setText("Re-pasted https://github.com/acme/paseo/pull/101");
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([]);
+    expect(client.calls).toEqual([]);
+    vi.useRealTimers();
+  });
+
+  it("handles multiple matching URLs from one paste", async () => {
+    vi.useFakeTimers();
+    const client = createSearchClient([pr101, issue202]);
+    const { result } = renderHook(() => useHarness(client), { wrapper: createWrapper() });
+
+    act(() => {
+      result.current.setText(
+        "Refs https://github.com/acme/paseo/pull/101 and https://github.com/acme/paseo/issues/202",
+      );
+    });
+    await flushDebounce();
+
+    expect(result.current.attachments).toEqual([
+      { kind: "github_pr", item: pr101 },
+      { kind: "github_issue", item: issue202 },
+    ]);
+    expect(client.calls).toEqual([
+      { cwd, query: "101", limit: 20 },
+      { cwd, query: "202", limit: 20 },
+    ]);
+    vi.useRealTimers();
+  });
+});

packages/app/src/components/use-composer-github-auto-attach.ts

@@ -0,0 +1,240 @@
+import { useQueryClient, type QueryClient } from "@tanstack/react-query";
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  type Dispatch,
+  type RefObject,
+  type SetStateAction,
+} from "react";
+import type { ComposerAttachment, UserComposerAttachment } from "@/attachments/types";
+import {
+  buildGithubSearchQueryOptions,
+  type GitHubSearchClient,
+} from "@/git/use-github-search-query";
+import { extractGithubRefs, type GithubRef } from "@/utils/github-refs";
+import type { GitHubSearchItem } from "@server/shared/messages";
+import { isAttachmentSelectedForGithubItem, toggleGithubAttachment } from "./composer-actions";
+
+const AUTO_ATTACH_DEBOUNCE_MS = 300;
+
+interface ComposerGithubAutoAttachInput {
+  text: string;
+  remoteUrl: string | null | undefined;
+  attachments: UserComposerAttachment[];
+  client: GitHubSearchClient | null;
+  isConnected: boolean;
+  serverId: string;
+  cwd: string;
+  setAttachments: Dispatch<SetStateAction<UserComposerAttachment[]>>;
+}
+
+interface ComposerGithubAutoAttachResult {
+  markGithubAttachmentRemoved: (attachment: ComposerAttachment | undefined) => void;
+}
+
+export function useComposerGithubAutoAttach(
+  params: ComposerGithubAutoAttachInput,
+): ComposerGithubAutoAttachResult {
+  const queryClient = useQueryClient();
+  const latestRef = useRef(params);
+  const removedRefKeysRef = useRef(new Set<string>());
+  const pendingRefKeysRef = useRef(new Set<string>());
+
+  latestRef.current = params;
+
+  useEffect(() => {
+    const refs = refsReadyForLookup({
+      params: latestRef.current,
+      removedRefKeys: removedRefKeysRef.current,
+      pendingRefKeys: pendingRefKeysRef.current,
+    });
+    if (refs.length === 0) {
+      return;
+    }
+
+    const timerId = setTimeout(() => {
+      void attachRefs({
+        refs,
+        queryClient,
+        latestRef,
+        removedRefKeys: removedRefKeysRef.current,
+        pendingRefKeys: pendingRefKeysRef.current,
+      });
+    }, AUTO_ATTACH_DEBOUNCE_MS);
+
+    return () => {
+      clearTimeout(timerId);
+    };
+  }, [
+    params.text,
+    params.remoteUrl,
+    params.attachments,
+    params.client,
+    params.isConnected,
+    params.serverId,
+    params.cwd,
+    queryClient,
+  ]);
+
+  const markGithubAttachmentRemoved = useCallback((attachment: ComposerAttachment | undefined) => {
+    const key = attachmentKey(attachment);
+    if (key) {
+      removedRefKeysRef.current.add(key);
+    }
+  }, []);
+
+  return useMemo(
+    () => ({
+      markGithubAttachmentRemoved,
+    }),
+    [markGithubAttachmentRemoved],
+  );
+}
+
+async function attachRefs({
+  refs,
+  queryClient,
+  latestRef,
+  removedRefKeys,
+  pendingRefKeys,
+}: {
+  refs: GithubRef[];
+  queryClient: QueryClient;
+  latestRef: RefObject<ComposerGithubAutoAttachInput>;
+  removedRefKeys: Set<string>;
+  pendingRefKeys: Set<string>;
+}): Promise<void> {
+  for (const ref of refs) {
+    const key = githubRefKey(ref);
+    if (pendingRefKeys.has(key)) {
+      continue;
+    }
+    pendingRefKeys.add(key);
+    try {
+      await attachRef({ ref, key, queryClient, latestRef, removedRefKeys });
+    } finally {
+      pendingRefKeys.delete(key);
+    }
+  }
+}
+
+async function attachRef({
+  ref,
+  key,
+  queryClient,
+  latestRef,
+  removedRefKeys,
+}: {
+  ref: GithubRef;
+  key: string;
+  queryClient: QueryClient;
+  latestRef: RefObject<ComposerGithubAutoAttachInput>;
+  removedRefKeys: Set<string>;
+}): Promise<void> {
+  const snapshot = latestRef.current;
+  if (!snapshot.client || !snapshot.isConnected || !isRefStillPresent(ref, snapshot)) {
+    return;
+  }
+
+  const search = await fetchGithubRefSearch({ ref, snapshot, queryClient });
+  if (!search) {
+    return;
+  }
+  const item = search.items.find((candidate) => githubItemMatchesRef(candidate, ref));
+  if (!item || removedRefKeys.has(key) || !isRefStillPresent(ref, latestRef.current)) {
+    return;
+  }
+
+  latestRef.current.setAttachments((current) => {
+    if (removedRefKeys.has(key) || isAttachmentSelectedForGithubItem(current, item)) {
+      return current;
+    }
+    return toggleGithubAttachment(current, item);
+  });
+}
+
+function refsReadyForLookup({
+  params,
+  removedRefKeys,
+  pendingRefKeys,
+}: {
+  params: ComposerGithubAutoAttachInput;
+  removedRefKeys: Set<string>;
+  pendingRefKeys: Set<string>;
+}): GithubRef[] {
+  if (!params.client || !params.isConnected || params.cwd.trim().length === 0) {
+    return [];
+  }
+
+  return extractGithubRefs(params.text, params.remoteUrl).filter((ref) => {
+    const key = githubRefKey(ref);
+    return (
+      !removedRefKeys.has(key) &&
+      !pendingRefKeys.has(key) &&
+      !hasGithubAttachment(params.attachments, ref)
+    );
+  });
+}
+
+async function fetchGithubRefSearch({
+  ref,
+  snapshot,
+  queryClient,
+}: {
+  ref: GithubRef;
+  snapshot: ComposerGithubAutoAttachInput;
+  queryClient: QueryClient;
+}) {
+  if (!snapshot.client) {
+    return null;
+  }
+
+  try {
+    return await queryClient.fetchQuery(
+      buildGithubSearchQueryOptions({
+        client: snapshot.client,
+        serverId: snapshot.serverId,
+        cwd: snapshot.cwd,
+        query: String(ref.number),
+        enabled: true,
+      }),
+    );
+  } catch {
+    return null;
+  }
+}
+
+function isRefStillPresent(ref: GithubRef, params: ComposerGithubAutoAttachInput): boolean {
+  return extractGithubRefs(params.text, params.remoteUrl).some(
+    (candidate) => githubRefKey(candidate) === githubRefKey(ref),
+  );
+}
+
+function hasGithubAttachment(attachments: UserComposerAttachment[], ref: GithubRef): boolean {
+  return attachments.some((attachment) => attachmentKey(attachment) === githubRefKey(ref));
+}
+
+function githubItemMatchesRef(item: GitHubSearchItem, ref: GithubRef): boolean {
+  return item.kind === githubItemKind(ref) && item.number === ref.number;
+}
+
+function githubItemKind(ref: GithubRef): GitHubSearchItem["kind"] {
+  return ref.kind === "pull" ? "pr" : "issue";
+}
+
+function githubRefKey(ref: GithubRef): string {
+  return `${githubItemKind(ref)}:${ref.number}`;
+}
+
+function attachmentKey(attachment: ComposerAttachment | undefined): string | null {
+  if (
+    !attachment ||
+    attachment.kind === "image" ||
+    (attachment.kind !== "github_pr" && attachment.kind !== "github_issue")
+  ) {
+    return null;
+  }
+  return `${attachment.item.kind}:${attachment.item.number}`;
+}

packages/app/src/components/use-web-scrollbar.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState, type ReactNode, type RefObject } from "react";
+import { useCallback, useLayoutEffect, useState, type ReactNode, type RefObject } from "react";
 import {
   type FlatList,
   type LayoutChangeEvent,
@@ -21,8 +21,25 @@ function ensureHideScrollbarStyle(): void {
   if (document.getElementById(HIDE_SCROLLBAR_STYLE_ID)) return;
   const style = document.createElement("style");
   style.id = HIDE_SCROLLBAR_STYLE_ID;
-  style.textContent =
-    "[data-hide-scrollbar]::-webkit-scrollbar { display: none; width: 0; height: 0; }";
+  style.textContent = `
+    [data-hide-scrollbar] {
+      scrollbar-width: none;
+      -ms-overflow-style: none;
+      scrollbar-gutter: auto;
+    }
+
+    [data-hide-scrollbar]::-webkit-scrollbar {
+      display: none;
+      width: 0;
+      height: 0;
+    }
+
+    [data-hide-scrollbar]::-webkit-scrollbar-button {
+      display: none;
+      width: 0;
+      height: 0;
+    }
+  `;
   document.head.appendChild(style);
 }
 
@@ -54,18 +71,25 @@ export function useWebElementScrollbar(
     contentSize: 0,
   });
 
-  useEffect(() => {
+  useLayoutEffect(() => {
     if (!enabled) return;
     const element = elementRef.current;
     if (!element) return;
 
+    type ScrollbarStyle = CSSStyleDeclaration & {
+      scrollbarWidth: string;
+      msOverflowStyle: string;
+      scrollbarGutter: string;
+    };
+    const style = element.style as ScrollbarStyle;
+    const previousScrollbarWidth = style.scrollbarWidth;
+    const previousMsOverflowStyle = style.msOverflowStyle;
+    const previousScrollbarGutter = style.scrollbarGutter;
+
     element.setAttribute("data-hide-scrollbar", "");
-    (
-      element.style as CSSStyleDeclaration & { scrollbarWidth: string; msOverflowStyle: string }
-    ).scrollbarWidth = "none";
-    (
-      element.style as CSSStyleDeclaration & { scrollbarWidth: string; msOverflowStyle: string }
-    ).msOverflowStyle = "none";
+    style.scrollbarWidth = "none";
+    style.msOverflowStyle = "none";
+    style.scrollbarGutter = "auto";
     ensureHideScrollbarStyle();
 
     function update() {
@@ -94,12 +118,9 @@ export function useWebElementScrollbar(
       element.removeEventListener("scroll", update);
       resizeObserver.disconnect();
       element.removeAttribute("data-hide-scrollbar");
-      (
-        element.style as CSSStyleDeclaration & { scrollbarWidth: string; msOverflowStyle: string }
-      ).scrollbarWidth = "";
-      (
-        element.style as CSSStyleDeclaration & { scrollbarWidth: string; msOverflowStyle: string }
-      ).msOverflowStyle = "";
+      style.scrollbarWidth = previousScrollbarWidth;
+      style.msOverflowStyle = previousMsOverflowStyle;
+      style.scrollbarGutter = previousScrollbarGutter;
     };
   }, [contentRef, elementRef, enabled]);
 

packages/app/src/components/workspace-hover-card.tsx

@@ -8,18 +8,10 @@ import {
   type ReactElement,
   type ReactNode,
 } from "react";
-import {
-  Dimensions,
-  Platform,
-  Text,
-  View,
-  type StyleProp,
-  type TextStyle,
-  type ViewStyle,
-} from "react-native";
+import { Dimensions, Text, View } from "react-native";
 import Animated, { FadeIn, FadeOut } from "react-native-reanimated";
 import { StyleSheet, withUnistyles } from "react-native-unistyles";
-import { ExternalLink } from "lucide-react-native";
+import { CircleCheck, CircleDot, CircleX, ExternalLink } from "lucide-react-native";
 import { GitHubIcon } from "@/components/icons/github-icon";
 import type { Theme } from "@/styles/theme";
 import { DiffStat } from "@/components/diff-stat";
@@ -31,6 +23,8 @@ import type { PrHint } from "@/git/use-pr-status-query";
 import { openExternalUrl } from "@/utils/open-external-url";
 import { PrBadge } from "@/components/sidebar-workspace-list";
 import { useHoverSafeZone } from "@/hooks/use-hover-safe-zone";
+import { useIsCompactFormFactor } from "@/constants/layout";
+import { isWeb } from "@/constants/platform";
 
 interface Rect {
   x: number;
@@ -92,8 +86,9 @@ export function WorkspaceHoverCard({
   isDragging,
   children,
 }: PropsWithChildren<WorkspaceHoverCardProps>): ReactNode {
-  // Desktop-only: skip on non-web platforms
-  if (Platform.OS !== "web") {
+  const isCompact = useIsCompactFormFactor();
+
+  if (!isWeb || isCompact) {
     return children;
   }
 
@@ -316,9 +311,62 @@ function WorkspaceHoverCardContent({
 
 const ThemedExternalLink = withUnistyles(ExternalLink);
 const ThemedGitHubIcon = withUnistyles(GitHubIcon);
+const ThemedCircleCheck = withUnistyles(CircleCheck);
+const ThemedCircleDot = withUnistyles(CircleDot);
+const ThemedCircleX = withUnistyles(CircleX);
 
 const foregroundColorMapping = (theme: Theme) => ({ color: theme.colors.foreground });
 const foregroundMutedColorMapping = (theme: Theme) => ({ color: theme.colors.foregroundMuted });
+const successColorMapping = (theme: Theme) => ({ color: theme.colors.statusSuccess });
+const warningColorMapping = (theme: Theme) => ({ color: theme.colors.statusWarning });
+const dangerColorMapping = (theme: Theme) => ({ color: theme.colors.statusDanger });
+
+function getChecksSummaryCounts(checks: NonNullable<PrHint["checks"]>) {
+  return checks.reduce(
+    (counts, check) => {
+      if (check.status === "success") counts.passed += 1;
+      else if (check.status === "failure") counts.failed += 1;
+      else if (check.status !== "skipped" && check.status !== "cancelled") counts.pending += 1;
+      return counts;
+    },
+    { passed: 0, failed: 0, pending: 0 },
+  );
+}
+
+function ChecksSummaryPill({
+  count,
+  kind,
+}: {
+  count: number;
+  kind: "passed" | "failed" | "pending";
+}) {
+  if (count === 0) return null;
+
+  if (kind === "passed") {
+    return (
+      <View style={styles.checksSummaryPill}>
+        <ThemedCircleCheck size={12} uniProps={successColorMapping} />
+        <Text style={styles.checksStatusTextPassed}>{count}</Text>
+      </View>
+    );
+  }
+
+  if (kind === "failed") {
+    return (
+      <View style={styles.checksSummaryPill}>
+        <ThemedCircleX size={12} uniProps={dangerColorMapping} />
+        <Text style={styles.checksStatusTextFailed}>{count}</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.checksSummaryPill}>
+      <ThemedCircleDot size={12} uniProps={warningColorMapping} />
+      <Text style={styles.checksStatusTextPending}>{count}</Text>
+    </View>
+  );
+}
 
 function ChecksSummaryContent({
   checks,
@@ -327,26 +375,7 @@ function ChecksSummaryContent({
   checks: NonNullable<PrHint["checks"]>;
   hovered: boolean;
 }) {
-  const failed = checks.filter((c) => c.status === "failure").length;
-  const pending = checks.filter((c) => c.status === "pending").length;
-
-  let badgeLabel: string;
-  let dotStyle: StyleProp<ViewStyle>;
-  let statusTextStyle: StyleProp<TextStyle>;
-
-  if (failed > 0) {
-    badgeLabel = `${failed} failed`;
-    dotStyle = styles.checksDotFailed;
-    statusTextStyle = styles.checksStatusTextFailed;
-  } else if (pending > 0) {
-    badgeLabel = `${pending} running`;
-    dotStyle = styles.checksDotPending;
-    statusTextStyle = styles.checksStatusTextPending;
-  } else {
-    badgeLabel = `${checks.length} passed`;
-    dotStyle = styles.checksDotPassed;
-    statusTextStyle = styles.checksStatusTextPassed;
-  }
+  const { passed, failed, pending } = getChecksSummaryCounts(checks);
 
   const labelStyle = hovered ? checksSummaryLabelHoveredCombined : styles.checksSummaryLabel;
   const iconUniProps = hovered ? foregroundColorMapping : foregroundMutedColorMapping;
@@ -360,8 +389,9 @@ function ChecksSummaryContent({
       )}
       <Text style={labelStyle}>Checks</Text>
       <View style={styles.checksSummaryCounts}>
-        <View style={dotStyle} />
-        <Text style={statusTextStyle}>{badgeLabel}</Text>
+        <ChecksSummaryPill count={passed} kind="passed" />
+        <ChecksSummaryPill count={failed} kind="failed" />
+        <ChecksSummaryPill count={pending} kind="pending" />
       </View>
     </>
   );
@@ -465,42 +495,29 @@ const styles = StyleSheet.create((theme) => ({
   checksSummaryCounts: {
     flexDirection: "row",
     alignItems: "center",
-    gap: 4,
+    gap: theme.spacing[2],
     flex: 1,
     justifyContent: "flex-end",
   },
-  checksDotFailed: {
-    width: 6,
-    height: 6,
-    borderRadius: 3,
-    backgroundColor: theme.colors.palette.red[500],
-  },
-  checksDotPending: {
-    width: 6,
-    height: 6,
-    borderRadius: 3,
-    backgroundColor: theme.colors.palette.amber[500],
-  },
-  checksDotPassed: {
-    width: 6,
-    height: 6,
-    borderRadius: 3,
-    backgroundColor: theme.colors.palette.green[500],
+  checksSummaryPill: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 3,
   },
   checksStatusTextFailed: {
     fontSize: theme.fontSize.xs,
     fontWeight: theme.fontWeight.normal,
-    color: theme.colors.palette.red[500],
+    color: theme.colors.statusDanger,
   },
   checksStatusTextPending: {
     fontSize: theme.fontSize.xs,
     fontWeight: theme.fontWeight.normal,
-    color: theme.colors.palette.amber[500],
+    color: theme.colors.statusWarning,
   },
   checksStatusTextPassed: {
     fontSize: theme.fontSize.xs,
     fontWeight: theme.fontWeight.normal,
-    color: theme.colors.palette.green[500],
+    color: theme.colors.statusSuccess,
   },
 }));
 

packages/app/src/constants/platform.ts

@@ -14,7 +14,9 @@ import { isElectronRuntime, isElectronRuntimeMac } from "@/desktop/host";
 //   isElectron → Desktop wrapper features (file dialogs, titlebar, updates)
 //
 // For layout decisions, use useIsCompactFormFactor() from constants/layout.ts.
-// For hover, use onHoverIn/onHoverOut on Pressable — no platform gate needed.
+// For hover-tracking, see docs/hover.md — the short answer is `onPointerEnter`/
+// `onPointerLeave` on a plain `View`, with any press behavior on a separate
+// inner `Pressable`. No platform gate needed.
 // ---------------------------------------------------------------------------
 
 /** Browser or Electron — the JS runtime has access to the DOM. */

packages/app/src/git/actions-split-button.tsx

@@ -97,6 +97,13 @@ export function GitActionsSplitButton({ gitActions, hideLabels }: GitActionsSpli
     [theme.colors.foreground, toast],
   );
 
+  const handlePrimaryPress = useCallback(() => {
+    if (!gitActions.primary) {
+      return;
+    }
+    handleActionSelect(gitActions.primary);
+  }, [gitActions.primary, handleActionSelect]);
+
   const overflowMenuButtonStyle = useMemo(() => [styles.iconButton, styles.overflowMenuButton], []);
 
   const primaryDisabled = gitActions.primary?.disabled;
@@ -124,7 +131,7 @@ export function GitActionsSplitButton({ gitActions, hideLabels }: GitActionsSpli
           <Pressable
             testID="changes-primary-cta"
             style={primaryPressableStyle}
-            onPress={gitActions.primary.handler}
+            onPress={handlePrimaryPress}
             disabled={gitActions.primary.disabled}
             accessibilityRole="button"
             accessibilityLabel={gitActions.primary.label}

packages/app/src/git/actions-store.test.ts

@@ -170,6 +170,91 @@ describe("checkout-git-actions-store", () => {
     ).toBe("idle");
   });
 
+  it("enables PR auto-merge when the daemon advertises auto-merge actions", async () => {
+    const client = {
+      checkoutGithubSetAutoMerge: vi.fn(async () => ({
+        enabled: true,
+        success: true,
+        error: null,
+      })),
+    };
+    useSessionStore.getState().initializeSession(serverId, client as unknown as DaemonClient);
+    useSessionStore.getState().updateSessionServerInfo(serverId, {
+      serverId,
+      hostname: null,
+      version: null,
+      features: { checkoutGithubSetAutoMerge: true },
+    });
+
+    await useCheckoutGitActionsStore
+      .getState()
+      .enablePrAutoMerge({ serverId, cwd, method: "squash" });
+
+    expect(client.checkoutGithubSetAutoMerge).toHaveBeenCalledWith(cwd, {
+      enabled: true,
+      method: "squash",
+    });
+    expect(
+      useCheckoutGitActionsStore
+        .getState()
+        .getStatus({ serverId, cwd, actionId: "enable-pr-auto-merge-squash" }),
+    ).toBe("success");
+  });
+
+  it("disables PR auto-merge when the daemon advertises auto-merge actions", async () => {
+    const client = {
+      checkoutGithubSetAutoMerge: vi.fn(async () => ({
+        enabled: false,
+        success: true,
+        error: null,
+      })),
+    };
+    useSessionStore.getState().initializeSession(serverId, client as unknown as DaemonClient);
+    useSessionStore.getState().updateSessionServerInfo(serverId, {
+      serverId,
+      hostname: null,
+      version: null,
+      features: { checkoutGithubSetAutoMerge: true },
+    });
+
+    await useCheckoutGitActionsStore.getState().disablePrAutoMerge({ serverId, cwd });
+
+    expect(client.checkoutGithubSetAutoMerge).toHaveBeenCalledWith(cwd, { enabled: false });
+    expect(
+      useCheckoutGitActionsStore
+        .getState()
+        .getStatus({ serverId, cwd, actionId: "disable-pr-auto-merge" }),
+    ).toBe("success");
+  });
+
+  it("does not call PR auto-merge RPCs when the daemon lacks the feature flag", async () => {
+    const client = {
+      checkoutGithubSetAutoMerge: vi.fn(async () => ({
+        enabled: true,
+        success: true,
+        error: null,
+      })),
+    };
+    useSessionStore.getState().initializeSession(serverId, client as unknown as DaemonClient);
+    useSessionStore.getState().updateSessionServerInfo(serverId, {
+      serverId,
+      hostname: null,
+      version: null,
+      features: {},
+    });
+
+    await expect(
+      useCheckoutGitActionsStore.getState().enablePrAutoMerge({ serverId, cwd, method: "merge" }),
+    ).rejects.toThrow("Update the host to use GitHub auto-merge actions.");
+
+    expect(client.checkoutGithubSetAutoMerge).not.toHaveBeenCalled();
+    expect(
+      useCheckoutGitActionsStore
+        .getState()
+        .getStatus({ serverId, cwd, actionId: "enable-pr-auto-merge-merge" }),
+    ).toBe("idle");
+  });
+
   it("hides an archived worktree optimistically while the archive RPC is in flight", async () => {
     const deferred = createDeferred<Record<string, never>>();
     const client = {

packages/app/src/git/actions-store.ts

@@ -32,6 +32,10 @@ export type CheckoutGitAsyncActionId =
   | "merge-pr-squash"
   | "merge-pr-merge"
   | "merge-pr-rebase"
+  | "enable-pr-auto-merge-squash"
+  | "enable-pr-auto-merge-merge"
+  | "enable-pr-auto-merge-rebase"
+  | "disable-pr-auto-merge"
   | "merge-branch"
   | "merge-from-base"
   | "archive-worktree";
@@ -52,6 +56,13 @@ function resolveClient(serverId: string) {
   return client;
 }
 
+function assertGitHubAutoMergeActionsSupported(serverId: string) {
+  const session = useSessionStore.getState().sessions[serverId];
+  if (session?.serverInfo?.features?.checkoutGithubSetAutoMerge !== true) {
+    throw new Error("Update the host to use GitHub auto-merge actions.");
+  }
+}
+
 function setStatus(
   key: CheckoutKey,
   actionId: CheckoutGitAsyncActionId,
@@ -231,6 +242,12 @@ interface CheckoutGitActionsStoreState {
     cwd: string;
     method: CheckoutPrMergeMethod;
   }) => Promise<void>;
+  enablePrAutoMerge: (params: {
+    serverId: string;
+    cwd: string;
+    method: CheckoutPrMergeMethod;
+  }) => Promise<void>;
+  disablePrAutoMerge: (params: { serverId: string; cwd: string }) => Promise<void>;
   mergeBranch: (params: { serverId: string; cwd: string; baseRef: string }) => Promise<void>;
   mergeFromBase: (params: { serverId: string; cwd: string; baseRef: string }) => Promise<void>;
   archiveWorktree: (params: {
@@ -392,6 +409,38 @@ export const useCheckoutGitActionsStore = create<CheckoutGitActionsStoreState>()
     });
   },
 
+  enablePrAutoMerge: async ({ serverId, cwd, method }) => {
+    assertGitHubAutoMergeActionsSupported(serverId);
+    await runCheckoutAction({
+      serverId,
+      cwd,
+      actionId: `enable-pr-auto-merge-${method}`,
+      run: async () => {
+        const client = resolveClient(serverId);
+        const payload = await client.checkoutGithubSetAutoMerge(cwd, { enabled: true, method });
+        if (payload.error) {
+          throw new Error(payload.error.message);
+        }
+      },
+    });
+  },
+
+  disablePrAutoMerge: async ({ serverId, cwd }) => {
+    assertGitHubAutoMergeActionsSupported(serverId);
+    await runCheckoutAction({
+      serverId,
+      cwd,
+      actionId: "disable-pr-auto-merge",
+      run: async () => {
+        const client = resolveClient(serverId);
+        const payload = await client.checkoutGithubSetAutoMerge(cwd, { enabled: false });
+        if (payload.error) {
+          throw new Error(payload.error.message);
+        }
+      },
+    });
+  },
+
   mergeBranch: async ({ serverId, cwd, baseRef }) => {
     await runCheckoutAction({
       serverId,

packages/app/src/git/diff-pane.tsx

@@ -54,11 +54,7 @@ import { useCheckoutStatusQuery } from "@/git/use-status-query";
 import { useCheckoutPrStatusQuery } from "@/git/use-pr-status-query";
 import { useChangesPreferences } from "@/hooks/use-changes-preferences";
 import { DiffScroll } from "@/components/diff-scroll";
-import {
-  darkHighlightColors,
-  lightHighlightColors,
-  type HighlightStyle as HighlightStyleKey,
-} from "@getpaseo/highlight";
+import { syntaxTokenStyleFor } from "@/styles/syntax-token-styles";
 import { WORKSPACE_SECONDARY_HEADER_HEIGHT } from "@/constants/layout";
 import { Fonts } from "@/constants/theme";
 import { shouldAnchorHeaderBeforeCollapse } from "@/git/diff-scroll";
@@ -136,8 +132,6 @@ function expandAllButtonStyle({
   return [styles.expandAllButton, (Boolean(hovered) || pressed) && styles.diffStatusRowHovered];
 }
 
-type HighlightStyle = NonNullable<HighlightToken["style"]>;
-
 interface HighlightedTextProps {
   tokens: HighlightToken[];
   wrapLines?: boolean;
@@ -157,31 +151,14 @@ function getWrappedTextStyle(wrapLines: boolean): WrappedWebTextStyle | undefine
     : { whiteSpace: "pre", overflowWrap: "normal" };
 }
 
-function HighlightedToken({
-  text,
-  color,
-  lineHeight,
-}: {
-  text: string;
-  color: string;
-  lineHeight: number;
-}) {
-  const tokenStyle = useMemo(() => ({ color, lineHeight }), [color, lineHeight]);
-  return <Text style={tokenStyle}>{text}</Text>;
+function HighlightedToken({ token }: { token: HighlightToken }) {
+  return <Text style={syntaxTokenStyleFor(token.style)}>{token.text}</Text>;
 }
 
 function HighlightedText({ tokens, wrapLines = false }: HighlightedTextProps) {
   const { theme } = useUnistyles();
-  const isDark = theme.colorScheme === "dark";
   const lineHeight = theme.lineHeight.diff;
 
-  const getTokenColor = (style: HighlightStyle | null): string => {
-    const baseColor = isDark ? "#c9d1d9" : "#24292f";
-    if (!style) return baseColor;
-    const colors = isDark ? darkHighlightColors : lightHighlightColors;
-    return colors[style as HighlightStyleKey] ?? baseColor;
-  };
-
   const containerStyle = useMemo(
     () => [styles.diffLineText, { lineHeight, ...getWrappedTextStyle(wrapLines) }],
     [lineHeight, wrapLines],
@@ -195,12 +172,7 @@ function HighlightedText({ tokens, wrapLines = false }: HighlightedTextProps) {
   return (
     <Text style={containerStyle}>
       {keyedTokens.map(({ key, token }) => (
-        <HighlightedToken
-          key={key}
-          text={token.text}
-          color={getTokenColor(token.style)}
-          lineHeight={lineHeight}
-        />
+        <HighlightedToken key={key} token={token} />
       ))}
     </Text>
   );
@@ -870,37 +842,46 @@ const DiffFileHeader = memo(function DiffFileHeader({
 
   return (
     <View style={containerStyle} onLayout={handleLayout} testID={testID}>
-      <Pressable
-        testID={testID ? `${testID}-toggle` : undefined}
-        style={fileHeaderPressableStyle}
-        // Android: prevent parent pan/scroll gestures from canceling the tap release.
-        cancelable={false}
-        onPressIn={handlePressIn}
-        onPressOut={handlePressOut}
-        onPress={toggleExpanded}
-      >
-        <View style={styles.fileHeaderLeft}>
-          <Text style={styles.fileName} numberOfLines={1}>
-            {file.path.split("/").pop()}
-          </Text>
-          <Text style={styles.fileDir} numberOfLines={1}>
-            {file.path.includes("/") ? ` ${file.path.slice(0, file.path.lastIndexOf("/"))}` : ""}
-          </Text>
-          {file.isNew && (
-            <View style={styles.newBadge}>
-              <Text style={styles.newBadgeText}>New</Text>
+      <Tooltip delayDuration={300} enabledOnDesktop enabledOnMobile={false}>
+        <TooltipTrigger asChild>
+          <Pressable
+            testID={testID ? `${testID}-toggle` : undefined}
+            style={fileHeaderPressableStyle}
+            // Android: prevent parent pan/scroll gestures from canceling the tap release.
+            cancelable={false}
+            onPressIn={handlePressIn}
+            onPressOut={handlePressOut}
+            onPress={toggleExpanded}
+          >
+            <View style={styles.fileHeaderLeft}>
+              <Text style={styles.fileName} numberOfLines={1}>
+                {file.path.split("/").pop()}
+              </Text>
+              <Text style={styles.fileDir} numberOfLines={1}>
+                {file.path.includes("/")
+                  ? ` ${file.path.slice(0, file.path.lastIndexOf("/"))}`
+                  : ""}
+              </Text>
+              {file.isNew && (
+                <View style={styles.newBadge}>
+                  <Text style={styles.newBadgeText}>New</Text>
+                </View>
+              )}
+              {file.isDeleted && (
+                <View style={styles.deletedBadge}>
+                  <Text style={styles.deletedBadgeText}>Deleted</Text>
+                </View>
+              )}
             </View>
-          )}
-          {file.isDeleted && (
-            <View style={styles.deletedBadge}>
-              <Text style={styles.deletedBadgeText}>Deleted</Text>
+            <View style={styles.fileHeaderRight}>
+              <DiffStat additions={file.additions} deletions={file.deletions} />
             </View>
-          )}
-        </View>
-        <View style={styles.fileHeaderRight}>
-          <DiffStat additions={file.additions} deletions={file.deletions} />
-        </View>
-      </Pressable>
+          </Pressable>
+        </TooltipTrigger>
+        <TooltipContent side="bottom" align="start" offset={6} maxWidth={520}>
+          <Text style={styles.tooltipText}>{file.path}</Text>
+        </TooltipContent>
+      </Tooltip>
     </View>
   );
 });

packages/app/src/git/policy.test.ts

@@ -1,17 +1,43 @@
 import { describe, expect, it } from "vitest";
+import { CheckoutPrStatusSchema } from "@server/shared/messages";
 
 import { buildGitActions, type BuildGitActionsInput } from "./policy";
 
+function githubStatus(
+  overrides: Partial<NonNullable<BuildGitActionsInput["pullRequestGithub"]>> = {},
+): NonNullable<BuildGitActionsInput["pullRequestGithub"]> {
+  return {
+    mergeStateStatus: "CLEAN",
+    autoMergeRequest: null,
+    viewerCanEnableAutoMerge: false,
+    viewerCanDisableAutoMerge: false,
+    viewerCanMergeAsAdmin: false,
+    viewerCanUpdateBranch: false,
+    repository: {
+      autoMergeAllowed: true,
+      mergeCommitAllowed: true,
+      squashMergeAllowed: true,
+      rebaseMergeAllowed: true,
+      viewerDefaultMergeMethod: "SQUASH",
+    },
+    isMergeQueueEnabled: false,
+    isInMergeQueue: false,
+    ...overrides,
+  };
+}
+
 function createInput(overrides: Partial<BuildGitActionsInput> = {}): BuildGitActionsInput {
   return {
     isGit: true,
     githubFeaturesEnabled: true,
+    githubAutoMergeActionsEnabled: true,
     hasPullRequest: false,
     pullRequestUrl: null,
     pullRequestState: null,
     pullRequestIsDraft: false,
     pullRequestIsMerged: false,
     pullRequestMergeable: "UNKNOWN",
+    pullRequestGithub: null,
     hasRemote: false,
     isPaseoOwnedWorktree: false,
     isOnBaseBranch: true,
@@ -65,6 +91,26 @@ function createInput(overrides: Partial<BuildGitActionsInput> = {}): BuildGitAct
         status: "idle",
         handler: () => undefined,
       },
+      "enable-pr-auto-merge-squash": {
+        disabled: false,
+        status: "idle",
+        handler: () => undefined,
+      },
+      "enable-pr-auto-merge-merge": {
+        disabled: false,
+        status: "idle",
+        handler: () => undefined,
+      },
+      "enable-pr-auto-merge-rebase": {
+        disabled: false,
+        status: "idle",
+        handler: () => undefined,
+      },
+      "disable-pr-auto-merge": {
+        disabled: false,
+        status: "idle",
+        handler: () => undefined,
+      },
       "merge-branch": {
         disabled: false,
         status: "idle",
@@ -167,6 +213,9 @@ describe("git-actions-policy", () => {
         behindBaseCount: 1,
         hasPullRequest: true,
         pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
       }),
     );
 
@@ -177,9 +226,6 @@ describe("git-actions-policy", () => {
       "merge-from-base",
       "merge-branch",
       "pr",
-      "merge-pr-squash",
-      "merge-pr-merge",
-      "merge-pr-rebase",
     ]);
     expect(
       actions.secondary.some((action) => action.id === "pr" && action.label === "View PR"),
@@ -246,6 +292,28 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(actions.primary).toMatchObject({
+      id: "merge-pr-squash",
+      label: "Squash and merge",
+    });
+  });
+
+  it("uses GitHub merge state, not mergeable, for direct merge readiness", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "UNKNOWN",
+        pullRequestGithub: githubStatus({ mergeStateStatus: "CLEAN" }),
         shipDefault: "pr",
       }),
     );
@@ -266,6 +334,7 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
         shipDefault: "pr",
       }),
     );
@@ -278,6 +347,7 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
         shipDefault: "merge",
       }),
     );
@@ -305,6 +375,7 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
       }),
     );
 
@@ -321,6 +392,73 @@ describe("git-actions-policy", () => {
     ]);
   });
 
+  it("keeps the visible PR action model stable on feature branches", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
+      }),
+    );
+    const pullRequestActions = actions.secondary
+      .filter((action) =>
+        ["pr", "merge-pr-squash", "merge-pr-merge", "merge-pr-rebase"].includes(action.id),
+      )
+      .map((action) => ({
+        id: action.id,
+        label: action.label,
+        pendingLabel: action.pendingLabel,
+        successLabel: action.successLabel,
+        disabled: action.disabled,
+        unavailableMessage: action.unavailableMessage,
+        startsGroup: action.startsGroup,
+      }));
+
+    expect(pullRequestActions).toEqual([
+      {
+        id: "pr",
+        label: "View PR",
+        pendingLabel: "View PR",
+        successLabel: "View PR",
+        disabled: false,
+        unavailableMessage: undefined,
+        startsGroup: false,
+      },
+      {
+        id: "merge-pr-squash",
+        label: "Squash and merge",
+        pendingLabel: "Merging PR...",
+        successLabel: "PR merged",
+        disabled: false,
+        unavailableMessage: undefined,
+        startsGroup: true,
+      },
+      {
+        id: "merge-pr-merge",
+        label: "Create a merge commit",
+        pendingLabel: "Merging PR...",
+        successLabel: "PR merged",
+        disabled: false,
+        unavailableMessage: undefined,
+        startsGroup: false,
+      },
+      {
+        id: "merge-pr-rebase",
+        label: "Rebase and merge",
+        pendingLabel: "Merging PR...",
+        successLabel: "PR merged",
+        disabled: false,
+        unavailableMessage: undefined,
+        startsGroup: false,
+      },
+    ]);
+  });
+
   it("uses Merge locally for the local merge action", () => {
     const actions = buildGitActions(
       createInput({
@@ -334,27 +472,11 @@ describe("git-actions-policy", () => {
   });
 
   it.each([
-    [
-      "draft",
-      { pullRequestIsDraft: true },
-      "Merge PR isn't available because the pull request is still a draft",
-    ],
-    [
-      "merged",
-      { pullRequestIsMerged: true },
-      "Merge PR isn't available because the pull request is already merged",
-    ],
-    [
-      "closed",
-      { pullRequestState: "closed" as const },
-      "Merge PR isn't available because the pull request is closed",
-    ],
-    [
-      "conflicting",
-      { pullRequestMergeable: "CONFLICTING" as const },
-      "Merge PR isn't available because the pull request has conflicts",
-    ],
-  ])("marks merge-pr actions unavailable when the PR is %s", (_name, overrides, message) => {
+    ["draft", { pullRequestIsDraft: true }],
+    ["merged", { pullRequestIsMerged: true }],
+    ["closed", { pullRequestState: "closed" as const }],
+    ["conflicting", { pullRequestMergeable: "CONFLICTING" as const }],
+  ])("does not offer direct merge actions when the PR is %s", (_name, overrides) => {
     const actions = buildGitActions(
       createInput({
         hasRemote: true,
@@ -364,6 +486,7 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
         ...overrides,
       }),
     );
@@ -371,13 +494,224 @@ describe("git-actions-policy", () => {
       ["merge-pr-squash", "merge-pr-merge", "merge-pr-rebase"].includes(action.id),
     );
 
-    expect(mergePrActions).toHaveLength(3);
-    expect(mergePrActions.map((action) => action.unavailableMessage)).toEqual([
-      message,
-      message,
-      message,
+    expect(mergePrActions).toEqual([]);
+    expect(actions.secondary).toEqual(
+      expect.arrayContaining([expect.objectContaining({ id: "pr", label: "View PR" })]),
+    );
+  });
+
+  it("preserves legacy direct merge actions when old payloads have no GitHub facts", () => {
+    const oldDaemonStatus = CheckoutPrStatusSchema.parse({
+      number: 456,
+      url: "https://example.com/pr/456",
+      title: "Legacy payload",
+      state: "open",
+      baseRefName: "main",
+      headRefName: "feature",
+      isMerged: false,
+      mergeable: "MERGEABLE",
+    });
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: oldDaemonStatus.url,
+        pullRequestState: "open",
+        pullRequestIsDraft: oldDaemonStatus.isDraft,
+        pullRequestIsMerged: oldDaemonStatus.isMerged,
+        pullRequestMergeable: oldDaemonStatus.mergeable,
+        pullRequestGithub: oldDaemonStatus.github,
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(oldDaemonStatus.github).toBeUndefined();
+    expect(actions.primary).toMatchObject({ id: "merge-pr-squash", label: "Squash and merge" });
+    expect(actions.secondary.map((action) => action.id)).toEqual([
+      "pull",
+      "push",
+      "pull-and-push",
+      "merge-from-base",
+      "merge-branch",
+      "pr",
+      "merge-pr-squash",
+      "merge-pr-merge",
+      "merge-pr-rebase",
     ]);
-    expect(mergePrActions.map((action) => action.disabled)).toEqual([true, true, true]);
+  });
+
+  it("requires GitHub's direct-merge allowlist before promoting PR merge", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/993",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus({
+          mergeStateStatus: "BLOCKED",
+          viewerCanEnableAutoMerge: true,
+          repository: {
+            autoMergeAllowed: true,
+            mergeCommitAllowed: false,
+            squashMergeAllowed: true,
+            rebaseMergeAllowed: false,
+            viewerDefaultMergeMethod: "SQUASH",
+          },
+        }),
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(actions.primary).toMatchObject({
+      id: "enable-pr-auto-merge-squash",
+      label: "Enable auto-merge with squash",
+    });
+    expect(actions.secondary.map((action) => action.id)).toEqual([
+      "pull",
+      "push",
+      "pull-and-push",
+      "merge-from-base",
+      "merge-branch",
+      "pr",
+      "enable-pr-auto-merge-squash",
+    ]);
+    expect(
+      actions.secondary.some((action) =>
+        ["merge-pr-squash", "merge-pr-merge", "merge-pr-rebase"].includes(action.id),
+      ),
+    ).toBe(false);
+  });
+
+  it("does not offer auto-merge when the daemon feature gate is missing", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/993",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus({
+          mergeStateStatus: "BLOCKED",
+          viewerCanEnableAutoMerge: true,
+        }),
+        githubAutoMergeActionsEnabled: false,
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(actions.primary).toMatchObject({ id: "pr", label: "View PR" });
+    expect(actions.secondary.some((action) => action.id.startsWith("enable-pr-auto-merge"))).toBe(
+      false,
+    );
+  });
+
+  it("shows existing auto-merge as state and disables it when the viewer can", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus({
+          autoMergeRequest: {
+            enabledAt: "2026-05-13T12:00:00Z",
+            mergeMethod: "SQUASH",
+            enabledBy: "octocat",
+          },
+          viewerCanDisableAutoMerge: true,
+        }),
+      }),
+    );
+
+    expect(actions.secondary).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: "disable-pr-auto-merge",
+          label: "Auto-merge enabled",
+          disabled: false,
+          unavailableMessage: undefined,
+        }),
+      ]),
+    );
+    expect(
+      actions.secondary.some((action) =>
+        ["merge-pr-squash", "merge-pr-merge", "merge-pr-rebase"].includes(action.id),
+      ),
+    ).toBe(false);
+  });
+
+  it("respects repository merge method policy for direct merge actions", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus({
+          repository: {
+            autoMergeAllowed: true,
+            mergeCommitAllowed: true,
+            squashMergeAllowed: false,
+            rebaseMergeAllowed: false,
+            viewerDefaultMergeMethod: "SQUASH",
+          },
+        }),
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(actions.primary).toMatchObject({
+      id: "merge-pr-merge",
+      label: "Create a merge commit",
+    });
+    expect(actions.secondary.map((action) => action.id)).toEqual([
+      "pull",
+      "push",
+      "pull-and-push",
+      "merge-from-base",
+      "merge-branch",
+      "pr",
+      "merge-pr-merge",
+    ]);
+  });
+
+  it("does not treat merge queue repositories as direct mergeable", () => {
+    const actions = buildGitActions(
+      createInput({
+        hasRemote: true,
+        isOnBaseBranch: false,
+        aheadCount: 2,
+        hasPullRequest: true,
+        pullRequestUrl: "https://example.com/pr/456",
+        pullRequestState: "open",
+        pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus({
+          mergeStateStatus: "CLEAN",
+          isMergeQueueEnabled: true,
+        }),
+        shipDefault: "pr",
+      }),
+    );
+
+    expect(actions.primary).toMatchObject({ id: "pr", label: "View PR" });
+    expect(
+      actions.secondary.some((action) =>
+        ["merge-pr-squash", "merge-pr-merge", "merge-pr-rebase"].includes(action.id),
+      ),
+    ).toBe(false);
   });
 
   it("groups merge-pr actions behind their own menu separator via startsGroup", () => {
@@ -390,6 +724,7 @@ describe("git-actions-policy", () => {
         pullRequestUrl: "https://example.com/pr/456",
         pullRequestState: "open",
         pullRequestMergeable: "MERGEABLE",
+        pullRequestGithub: githubStatus(),
         isPaseoOwnedWorktree: true,
       }),
     );

packages/app/src/git/policy.ts

@@ -1,7 +1,11 @@
 import type { ReactElement } from "react";
 
 import type { ActionStatus } from "@/components/ui/dropdown-menu";
-import type { CheckoutPrMergeMethod, PullRequestMergeable } from "@server/shared/messages";
+import type {
+  CheckoutPrMergeMethod,
+  CheckoutPrStatusResponse,
+  PullRequestMergeable,
+} from "@server/shared/messages";
 
 export type GitActionId =
   | "commit"
@@ -12,6 +16,10 @@ export type GitActionId =
   | "merge-pr-squash"
   | "merge-pr-merge"
   | "merge-pr-rebase"
+  | "enable-pr-auto-merge-squash"
+  | "enable-pr-auto-merge-merge"
+  | "enable-pr-auto-merge-rebase"
+  | "disable-pr-auto-merge"
   | "merge-branch"
   | "merge-from-base"
   | "archive-worktree";
@@ -46,12 +54,14 @@ interface GitActionRuntimeState {
 export interface BuildGitActionsInput {
   isGit: boolean;
   githubFeaturesEnabled: boolean;
+  githubAutoMergeActionsEnabled: boolean;
   hasPullRequest: boolean;
   pullRequestUrl: string | null;
   pullRequestState: "open" | "closed" | null;
   pullRequestIsDraft: boolean;
   pullRequestIsMerged: boolean;
   pullRequestMergeable: PullRequestMergeable;
+  pullRequestGithub: PullRequestGithubStatus | null;
   hasRemote: boolean;
   isPaseoOwnedWorktree: boolean;
   isOnBaseBranch: boolean;
@@ -67,24 +77,117 @@ export interface BuildGitActionsInput {
   runtime: Record<GitActionId, GitActionRuntimeState>;
 }
 
-const REMOTE_ACTION_IDS: GitActionId[] = ["pull", "push", "pull-and-push"];
-const FEATURE_ACTION_IDS: GitActionId[] = [
-  "merge-from-base",
-  "merge-branch",
-  "pr",
-  "merge-pr-squash",
-  "merge-pr-merge",
-  "merge-pr-rebase",
+type PullRequestActionId = Extract<
+  GitActionId,
+  | "pr"
+  | "merge-pr-squash"
+  | "merge-pr-merge"
+  | "merge-pr-rebase"
+  | "enable-pr-auto-merge-squash"
+  | "enable-pr-auto-merge-merge"
+  | "enable-pr-auto-merge-rebase"
+  | "disable-pr-auto-merge"
+>;
+type PullRequestDirectMergeActionId = Extract<
+  GitActionId,
+  "merge-pr-squash" | "merge-pr-merge" | "merge-pr-rebase"
+>;
+type PullRequestAutoMergeEnableActionId = Extract<
+  GitActionId,
+  "enable-pr-auto-merge-squash" | "enable-pr-auto-merge-merge" | "enable-pr-auto-merge-rebase"
+>;
+type PullRequestActionRole = "status" | "direct" | "auto";
+type PullRequestGithubStatus = NonNullable<CheckoutPrStatusResponse["payload"]["status"]>["github"];
+
+interface PullRequestActionModel {
+  readonly id: PullRequestActionId;
+  readonly role: PullRequestActionRole;
+  readonly build: (input: BuildGitActionsInput) => GitAction;
+}
+
+interface PullRequestDirectMergeActionModel {
+  readonly id: PullRequestDirectMergeActionId;
+  readonly role: "direct";
+  readonly label: string;
+  readonly method: CheckoutPrMergeMethod;
+  readonly startsGroup: boolean;
+}
+
+interface PullRequestAutoMergeEnableActionModel {
+  readonly id: PullRequestAutoMergeEnableActionId;
+  readonly role: "auto";
+  readonly label: string;
+  readonly method: CheckoutPrMergeMethod;
+  readonly startsGroup: boolean;
+}
+
+const PULL_REQUEST_DIRECT_MERGE_ACTION_MODELS = [
+  {
+    id: "merge-pr-squash",
+    role: "direct",
+    label: "Squash and merge",
+    method: "squash",
+    startsGroup: true,
+  },
+  {
+    id: "merge-pr-merge",
+    role: "direct",
+    label: "Create a merge commit",
+    method: "merge",
+    startsGroup: false,
+  },
+  {
+    id: "merge-pr-rebase",
+    role: "direct",
+    label: "Rebase and merge",
+    method: "rebase",
+    startsGroup: false,
+  },
+] as const satisfies readonly PullRequestDirectMergeActionModel[];
+
+const PULL_REQUEST_AUTO_MERGE_ENABLE_ACTION_MODELS = [
+  {
+    id: "enable-pr-auto-merge-squash",
+    role: "auto",
+    label: "Enable auto-merge with squash",
+    method: "squash",
+    startsGroup: true,
+  },
+  {
+    id: "enable-pr-auto-merge-merge",
+    role: "auto",
+    label: "Enable auto-merge with merge commit",
+    method: "merge",
+    startsGroup: false,
+  },
+  {
+    id: "enable-pr-auto-merge-rebase",
+    role: "auto",
+    label: "Enable auto-merge with rebase",
+    method: "rebase",
+    startsGroup: false,
+  },
+] as const satisfies readonly PullRequestAutoMergeEnableActionModel[];
+
+const PULL_REQUEST_ACTION_MODELS: readonly PullRequestActionModel[] = [
+  { id: "pr", role: "status", build: buildPrAction },
+  ...PULL_REQUEST_DIRECT_MERGE_ACTION_MODELS.map((model) => ({
+    ...model,
+    build: (input: BuildGitActionsInput) => buildDirectPullRequestMergeAction(input, model),
+  })),
+  ...PULL_REQUEST_AUTO_MERGE_ENABLE_ACTION_MODELS.map((model) => ({
+    ...model,
+    build: (input: BuildGitActionsInput) => buildEnablePullRequestAutoMergeAction(input, model),
+  })),
+  {
+    id: "disable-pr-auto-merge",
+    role: "auto",
+    build: buildDisablePullRequestAutoMergeAction,
+  },
 ];
 
-const MERGE_PR_METHODS: Record<
-  "merge-pr-squash" | "merge-pr-merge" | "merge-pr-rebase",
-  { label: string; method: CheckoutPrMergeMethod }
-> = {
-  "merge-pr-squash": { label: "Squash and merge", method: "squash" },
-  "merge-pr-merge": { label: "Create a merge commit", method: "merge" },
-  "merge-pr-rebase": { label: "Rebase and merge", method: "rebase" },
-};
+const REMOTE_ACTION_IDS: GitActionId[] = ["pull", "push", "pull-and-push"];
+const GITHUB_DIRECT_MERGE_STATE_ALLOWLIST = new Set(["CLEAN", "HAS_HOOKS"]);
 
 export function narrowPullRequestState(state: string | null | undefined): "open" | "closed" | null {
   if (state === "open") return "open";
@@ -152,11 +255,9 @@ export function buildGitActions(input: BuildGitActionsInput): GitActions {
     handler: input.runtime["pull-and-push"].handler,
   });
 
-  allActions.set("pr", buildPrAction(input));
-
-  allActions.set("merge-pr-squash", buildMergePrAction(input, "merge-pr-squash"));
-  allActions.set("merge-pr-merge", buildMergePrAction(input, "merge-pr-merge"));
-  allActions.set("merge-pr-rebase", buildMergePrAction(input, "merge-pr-rebase"));
+  for (const model of PULL_REQUEST_ACTION_MODELS) {
+    allActions.set(model.id, model.build(input));
+  }
 
   allActions.set("merge-branch", {
     id: "merge-branch",
@@ -209,7 +310,7 @@ export function buildGitActions(input: BuildGitActionsInput): GitActions {
 
   const secondaryIds = [...REMOTE_ACTION_IDS];
   if (!input.isOnBaseBranch) {
-    secondaryIds.push(...FEATURE_ACTION_IDS);
+    secondaryIds.push(...getFeatureActionIds(input));
   }
   if (input.isPaseoOwnedWorktree) {
     secondaryIds.push("archive-worktree");
@@ -239,7 +340,10 @@ function getPrimaryActionId(input: BuildGitActionsInput): GitActionId | null {
     return "merge-from-base";
   }
   if (canMergePr(input) && input.shipDefault === "pr") {
-    return "merge-pr-squash";
+    return getDefaultDirectPullRequestMergeActionId(input);
+  }
+  if (canEnablePrAutoMerge(input) && input.shipDefault === "pr") {
+    return getDefaultEnablePullRequestAutoMergeActionId(input);
   }
   if (!input.isOnBaseBranch && input.aheadCount > 0 && input.shipDefault === "merge") {
     return "merge-branch";
@@ -253,6 +357,41 @@ function getPrimaryActionId(input: BuildGitActionsInput): GitActionId | null {
   return null;
 }
 
+function getPullRequestActionIds(filter: {
+  roles: readonly PullRequestActionRole[];
+  input: BuildGitActionsInput;
+}): PullRequestActionId[] {
+  return PULL_REQUEST_ACTION_MODELS.filter((model) => filter.roles.includes(model.role))
+    .filter((model) => shouldShowPullRequestAction(filter.input, model.id))
+    .map((model) => model.id);
+}
+
+function getFeatureActionIds(input: BuildGitActionsInput): GitActionId[] {
+  return [
+    "merge-from-base",
+    "merge-branch",
+    ...getPullRequestActionIds({ roles: ["status", "direct", "auto"], input }),
+  ];
+}
+
+function getDefaultDirectPullRequestMergeActionId(
+  input: BuildGitActionsInput,
+): PullRequestDirectMergeActionId {
+  return (
+    getPreferredDirectPullRequestMergeActionModel(input)?.id ??
+    PULL_REQUEST_DIRECT_MERGE_ACTION_MODELS[0].id
+  );
+}
+
+function getDefaultEnablePullRequestAutoMergeActionId(
+  input: BuildGitActionsInput,
+): PullRequestAutoMergeEnableActionId {
+  return (
+    getPreferredEnablePullRequestAutoMergeActionModel(input)?.id ??
+    PULL_REQUEST_AUTO_MERGE_ENABLE_ACTION_MODELS[0].id
+  );
+}
+
 function buildPrAction(input: BuildGitActionsInput): GitAction {
   if (input.hasPullRequest && input.pullRequestUrl) {
     return {
@@ -288,23 +427,60 @@ function buildPrAction(input: BuildGitActionsInput): GitAction {
   };
 }
 
-function buildMergePrAction(
+function buildDirectPullRequestMergeAction(
   input: BuildGitActionsInput,
-  id: "merge-pr-squash" | "merge-pr-merge" | "merge-pr-rebase",
+  model: PullRequestDirectMergeActionModel,
 ): GitAction {
-  const runtime = input.runtime[id];
-  const config = MERGE_PR_METHODS[id];
+  const runtime = input.runtime[model.id];
   const unavailableMessage = getMergePrUnavailableMessage(input);
   return {
-    id,
-    label: config.label,
+    id: model.id,
+    label: model.label,
     pendingLabel: "Merging PR...",
     successLabel: "PR merged",
     disabled: runtime.disabled || shouldDisableMergePrAction(input),
     status: runtime.status,
     unavailableMessage: runtime.disabled ? undefined : unavailableMessage,
     icon: runtime.icon,
-    startsGroup: id === "merge-pr-squash",
+    startsGroup: model.startsGroup,
+    handler: runtime.handler,
+  };
+}
+
+function buildEnablePullRequestAutoMergeAction(
+  input: BuildGitActionsInput,
+  model: PullRequestAutoMergeEnableActionModel,
+): GitAction {
+  const runtime = input.runtime[model.id];
+  return {
+    id: model.id,
+    label: model.label,
+    pendingLabel: "Enabling auto-merge...",
+    successLabel: "Auto-merge enabled",
+    disabled: runtime.disabled,
+    status: runtime.status,
+    icon: runtime.icon,
+    startsGroup: model.startsGroup,
+    handler: runtime.handler,
+  };
+}
+
+function buildDisablePullRequestAutoMergeAction(input: BuildGitActionsInput): GitAction {
+  const runtime = input.runtime["disable-pr-auto-merge"];
+  const unavailableMessage =
+    input.pullRequestGithub?.viewerCanDisableAutoMerge === true
+      ? undefined
+      : "Auto-merge is enabled, but this account can't disable it";
+  return {
+    id: "disable-pr-auto-merge",
+    label: "Auto-merge enabled",
+    pendingLabel: "Disabling auto-merge...",
+    successLabel: "Auto-merge disabled",
+    disabled: runtime.disabled || input.pullRequestGithub?.viewerCanDisableAutoMerge !== true,
+    status: runtime.status,
+    unavailableMessage: runtime.disabled ? undefined : unavailableMessage,
+    icon: runtime.icon,
+    startsGroup: true,
     handler: runtime.handler,
   };
 }
@@ -327,18 +503,55 @@ function canMergeFromBase(input: BuildGitActionsInput): boolean {
 }
 
 function canMergePr(input: BuildGitActionsInput): boolean {
-  return (
+  const github = input.pullRequestGithub;
+  const canMergeFromTopLevelStatus =
     input.githubFeaturesEnabled &&
     input.hasPullRequest &&
     input.pullRequestState === "open" &&
     !input.pullRequestIsDraft &&
     !input.pullRequestIsMerged &&
-    input.pullRequestMergeable === "MERGEABLE" &&
+    input.pullRequestMergeable !== "CONFLICTING" &&
     input.aheadCount > 0 &&
     !input.hasUncommittedChanges &&
     input.behindOfOrigin === 0 &&
     input.aheadOfOrigin === 0 &&
-    !canMergeFromBase(input)
+    !canMergeFromBase(input);
+
+  if (!canMergeFromTopLevelStatus) {
+    return false;
+  }
+
+  if (!hasPullRequestGithubFacts(github)) {
+    return input.pullRequestMergeable === "MERGEABLE";
+  }
+
+  return (
+    GITHUB_DIRECT_MERGE_STATE_ALLOWLIST.has(github.mergeStateStatus ?? "") &&
+    github.autoMergeRequest === null &&
+    !github.isMergeQueueEnabled &&
+    !github.isInMergeQueue &&
+    getAllowedDirectPullRequestMergeActionModels(input).length > 0
+  );
+}
+
+function canEnablePrAutoMerge(input: BuildGitActionsInput): boolean {
+  const github = input.pullRequestGithub;
+  return (
+    input.githubFeaturesEnabled &&
+    input.githubAutoMergeActionsEnabled &&
+    input.hasPullRequest &&
+    input.pullRequestState === "open" &&
+    !input.pullRequestIsDraft &&
+    !input.pullRequestIsMerged &&
+    input.pullRequestMergeable !== "CONFLICTING" &&
+    hasPullRequestGithubFacts(github) &&
+    github.autoMergeRequest === null &&
+    github.mergeStateStatus === "BLOCKED" &&
+    github.repository.autoMergeAllowed &&
+    github.viewerCanEnableAutoMerge &&
+    !github.isMergeQueueEnabled &&
+    !github.isInMergeQueue &&
+    getAllowedAutoMergeEnableActionModels(input).length > 0
   );
 }
 
@@ -436,14 +649,131 @@ function getMergePrUnavailableMessage(input: BuildGitActionsInput): string | und
   if (input.pullRequestMergeable === "CONFLICTING") {
     return "Merge PR isn't available because the pull request has conflicts";
   }
+  if (!hasPullRequestGithubFacts(input.pullRequestGithub)) {
+    return undefined;
+  }
+  if (input.pullRequestGithub?.isMergeQueueEnabled || input.pullRequestGithub?.isInMergeQueue) {
+    return "Merge PR isn't available here because this repository uses a merge queue";
+  }
+  if (!GITHUB_DIRECT_MERGE_STATE_ALLOWLIST.has(input.pullRequestGithub?.mergeStateStatus ?? "")) {
+    return "Merge PR isn't available until GitHub reports the pull request is ready to merge";
+  }
   return undefined;
 }
 
 function shouldDisableMergePrAction(input: BuildGitActionsInput): boolean {
-  return (
-    input.pullRequestIsDraft ||
-    input.pullRequestIsMerged ||
-    input.pullRequestState === "closed" ||
-    input.pullRequestMergeable === "CONFLICTING"
+  return !canMergePr(input);
+}
+
+function shouldShowPullRequestAction(
+  input: BuildGitActionsInput,
+  id: PullRequestActionId,
+): boolean {
+  if (id === "pr") {
+    return true;
+  }
+  if (id === "disable-pr-auto-merge") {
+    return (
+      input.githubAutoMergeActionsEnabled &&
+      hasPullRequestGithubFacts(input.pullRequestGithub) &&
+      input.pullRequestGithub.autoMergeRequest !== null
+    );
+  }
+  if (isDirectPullRequestMergeActionId(id)) {
+    return canMergePr(input) && getAllowedDirectPullRequestMergeActionIds(input).includes(id);
+  }
+  if (isEnablePullRequestAutoMergeActionId(id)) {
+    return canEnablePrAutoMerge(input) && getAllowedAutoMergeEnableActionIds(input).includes(id);
+  }
+  return false;
+}
+
+function isDirectPullRequestMergeActionId(
+  id: PullRequestActionId,
+): id is PullRequestDirectMergeActionId {
+  return PULL_REQUEST_DIRECT_MERGE_ACTION_MODELS.some((model) => model.id === id);
+}
+
+function isEnablePullRequestAutoMergeActionId(
+  id: PullRequestActionId,
+): id is PullRequestAutoMergeEnableActionId {
+  return PULL_REQUEST_AUTO_MERGE_ENABLE_ACTION_MODELS.some((model) => model.id === id);
+}
+
+function getAllowedDirectPullRequestMergeActionIds(
+  input: BuildGitActionsInput,
+): PullRequestDirectMergeActionId[] {
+  return getAllowedDirectPullRequestMergeActionModels(input).map((model) => model.id);
+}
+
+function getAllowedAutoMergeEnableActionIds(
+  input: BuildGitActionsInput,
+): PullRequestAutoMergeEnableActionId[] {
+  return getAllowedAutoMergeEnableActionModels(input).map((model) => model.id);
+}
+
+function getAllowedDirectPullRequestMergeActionModels(
+  input: BuildGitActionsInput,
+): readonly PullRequestDirectMergeActionModel[] {
+  return PULL_REQUEST_DIRECT_MERGE_ACTION_MODELS.filter((model) =>
+    isPullRequestMergeMethodAllowed(input, model.method),
   );
 }
+
+function getAllowedAutoMergeEnableActionModels(
+  input: BuildGitActionsInput,
+): readonly PullRequestAutoMergeEnableActionModel[] {
+  return PULL_REQUEST_AUTO_MERGE_ENABLE_ACTION_MODELS.filter((model) =>
+    isPullRequestMergeMethodAllowed(input, model.method),
+  );
+}
+
+function getPreferredDirectPullRequestMergeActionModel(
+  input: BuildGitActionsInput,
+): PullRequestDirectMergeActionModel | null {
+  const allowed = getAllowedDirectPullRequestMergeActionModels(input);
+  const preferred = normalizeGithubMergeMethod(
+    input.pullRequestGithub?.repository.viewerDefaultMergeMethod ?? null,
+  );
+  return allowed.find((model) => model.method === preferred) ?? allowed[0] ?? null;
+}
+
+function getPreferredEnablePullRequestAutoMergeActionModel(
+  input: BuildGitActionsInput,
+): PullRequestAutoMergeEnableActionModel | null {
+  const allowed = getAllowedAutoMergeEnableActionModels(input);
+  const preferred = normalizeGithubMergeMethod(
+    input.pullRequestGithub?.repository.viewerDefaultMergeMethod ?? null,
+  );
+  return allowed.find((model) => model.method === preferred) ?? allowed[0] ?? null;
+}
+
+function isPullRequestMergeMethodAllowed(
+  input: BuildGitActionsInput,
+  method: CheckoutPrMergeMethod,
+): boolean {
+  const repository = input.pullRequestGithub?.repository;
+  if (!repository) {
+    return true;
+  }
+  if (method === "squash") {
+    return repository.squashMergeAllowed;
+  }
+  if (method === "merge") {
+    return repository.mergeCommitAllowed;
+  }
+  return repository.rebaseMergeAllowed;
+}
+
+function hasPullRequestGithubFacts(
+  github: PullRequestGithubStatus | null,
+): github is NonNullable<PullRequestGithubStatus> {
+  return github !== null && github !== undefined;
+}
+
+function normalizeGithubMergeMethod(value: string | null): CheckoutPrMergeMethod | null {
+  if (value === "SQUASH") return "squash";
+  if (value === "MERGE") return "merge";
+  if (value === "REBASE") return "rebase";
+  return null;
+}

packages/app/src/git/pr-pane-data.test.ts

@@ -14,6 +14,24 @@ import {
 type CheckoutPrStatus = NonNullable<CheckoutPrStatusResponse["payload"]["status"]>;
 type PullRequestTimeline = PullRequestTimelineResponse["payload"];
 
+const githubStatus: CheckoutPrStatus["github"] = {
+  mergeStateStatus: null,
+  autoMergeRequest: null,
+  viewerCanEnableAutoMerge: false,
+  viewerCanDisableAutoMerge: false,
+  viewerCanMergeAsAdmin: false,
+  viewerCanUpdateBranch: false,
+  repository: {
+    autoMergeAllowed: false,
+    mergeCommitAllowed: false,
+    squashMergeAllowed: false,
+    rebaseMergeAllowed: false,
+    viewerDefaultMergeMethod: null,
+  },
+  isMergeQueueEnabled: false,
+  isInMergeQueue: false,
+};
+
 const baseStatus: CheckoutPrStatus = {
   number: 42,
   url: "https://github.com/getpaseo/paseo/pull/42",
@@ -26,6 +44,7 @@ const baseStatus: CheckoutPrStatus = {
   mergeable: "UNKNOWN",
   checks: [],
   reviewDecision: null,
+  github: githubStatus,
 };
 
 const baseTimeline: PullRequestTimeline = {

packages/app/src/git/use-actions.ts

@@ -11,6 +11,7 @@ import { useToast } from "@/contexts/toast-context";
 import { useSessionStore } from "@/stores/session-store";
 import { resolveWorkspaceIdByExecutionDirectory } from "@/utils/workspace-execution";
 import { buildWorkspaceArchiveRedirectRoute } from "@/utils/workspace-archive-navigation";
+import { confirmRiskyWorktreeArchive } from "@/git/worktree-archive-warning";
 
 export type { GitActionId, GitAction, GitActions } from "@/git/policy";
 
@@ -169,6 +170,11 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     cwd,
     enabled: isGit,
   });
+  const baseRefLabel = useMemo(() => formatBaseRefLabel(baseRef), [baseRef]);
+  const branchLabel = resolveBranchLabel({
+    currentBranch: gitStatus?.currentBranch,
+    notGit,
+  });
 
   // Ship default persistence
   const shipDefaultStorageKey = useMemo(() => {
@@ -240,6 +246,20 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
       s.getStatus({ serverId, cwd, actionId: "merge-pr-rebase" }),
     ),
   };
+  const enablePrAutoMergeStatuses: Record<CheckoutPrMergeMethod, CheckoutGitActionStatus> = {
+    squash: useCheckoutGitActionsStore((s) =>
+      s.getStatus({ serverId, cwd, actionId: "enable-pr-auto-merge-squash" }),
+    ),
+    merge: useCheckoutGitActionsStore((s) =>
+      s.getStatus({ serverId, cwd, actionId: "enable-pr-auto-merge-merge" }),
+    ),
+    rebase: useCheckoutGitActionsStore((s) =>
+      s.getStatus({ serverId, cwd, actionId: "enable-pr-auto-merge-rebase" }),
+    ),
+  };
+  const disablePrAutoMergeStatus = useCheckoutGitActionsStore((s) =>
+    s.getStatus({ serverId, cwd, actionId: "disable-pr-auto-merge" }),
+  );
   const mergeStatus = useCheckoutGitActionsStore((s) =>
     s.getStatus({ serverId, cwd, actionId: "merge-branch" }),
   );
@@ -256,9 +276,14 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
   const runPullAndPush = useCheckoutGitActionsStore((s) => s.pullAndPush);
   const runCreatePr = useCheckoutGitActionsStore((s) => s.createPr);
   const runMergePr = useCheckoutGitActionsStore((s) => s.mergePr);
+  const runEnablePrAutoMerge = useCheckoutGitActionsStore((s) => s.enablePrAutoMerge);
+  const runDisablePrAutoMerge = useCheckoutGitActionsStore((s) => s.disablePrAutoMerge);
   const runMergeBranch = useCheckoutGitActionsStore((s) => s.mergeBranch);
   const runMergeFromBase = useCheckoutGitActionsStore((s) => s.mergeFromBase);
   const runArchiveWorktree = useCheckoutGitActionsStore((s) => s.archiveWorktree);
+  const githubAutoMergeActionsEnabled = useSessionStore(
+    (s) => s.sessions[serverId]?.serverInfo?.features?.checkoutGithubSetAutoMerge === true,
+  );
 
   const toastActionError = useCallback(
     (error: unknown, fallback: string) => {
@@ -348,6 +373,32 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     [cwd, persistShipDefault, runMergePr, serverId, toastActionError, toastActionSuccess],
   );
 
+  const handleEnablePrAutoMerge = useCallback(
+    (method: CheckoutPrMergeMethod) => {
+      void persistShipDefault("pr");
+      void runEnablePrAutoMerge({ serverId, cwd, method })
+        .then(() => {
+          toastActionSuccess("Auto-merge enabled");
+          return;
+        })
+        .catch((err) => {
+          toastActionError(err, "Failed to enable auto-merge");
+        });
+    },
+    [cwd, persistShipDefault, runEnablePrAutoMerge, serverId, toastActionError, toastActionSuccess],
+  );
+
+  const handleDisablePrAutoMerge = useCallback(() => {
+    void runDisablePrAutoMerge({ serverId, cwd })
+      .then(() => {
+        toastActionSuccess("Auto-merge disabled");
+        return;
+      })
+      .catch((err) => {
+        toastActionError(err, "Failed to disable auto-merge");
+      });
+  }, [cwd, runDisablePrAutoMerge, serverId, toastActionError, toastActionSuccess]);
+
   const handleMergeBranch = useCallback(() => {
     if (!baseRef) {
       toast.error("Base ref unavailable");
@@ -389,31 +440,59 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
       });
   }, [baseRef, cwd, runMergeFromBase, serverId, toast, toastActionError, toastActionSuccess]);
 
-  const handleArchiveWorktree = useCallback(() => {
+  const archiveWorktreeAfterConfirmation = useCallback(async () => {
     const worktreePath = status?.cwd;
     if (!worktreePath) {
       toast.error("Worktree path unavailable");
       return;
     }
+
     const workspaces = useSessionStore.getState().sessions[serverId]?.workspaces;
+    const workspaceList = Array.from(workspaces?.values() ?? []);
+    const workspace = workspaceList.find(
+      (candidate) => candidate.workspaceDirectory === worktreePath,
+    );
+    const confirmed = await confirmRiskyWorktreeArchive({
+      worktreeName: workspace?.name ?? branchLabel,
+      isDirty: gitStatus?.isDirty,
+      aheadOfOrigin: gitStatus?.aheadOfOrigin,
+      diffStat: workspace?.diffStat ?? null,
+    });
+    if (!confirmed) {
+      return;
+    }
+
     const archivedWorkspaceId =
       resolveWorkspaceIdByExecutionDirectory({
-        workspaces: workspaces?.values(),
+        workspaces: workspaceList,
         workspaceDirectory: worktreePath,
       }) ?? worktreePath;
     router.replace(
       buildWorkspaceArchiveRedirectRoute({
         serverId,
         archivedWorkspaceId,
-        workspaces: workspaces?.values() ?? [],
+        workspaces: workspaceList,
       }) as Href,
     );
     void runArchiveWorktree({ serverId, cwd, worktreePath }).catch((err) => {
       toastActionError(err, "Failed to archive worktree");
     });
-  }, [cwd, runArchiveWorktree, serverId, status, toast, toastActionError]);
+  }, [
+    branchLabel,
+    cwd,
+    gitStatus?.aheadOfOrigin,
+    gitStatus?.isDirty,
+    runArchiveWorktree,
+    serverId,
+    status?.cwd,
+    toast,
+    toastActionError,
+  ]);
+
+  const handleArchiveWorktree = useCallback(() => {
+    void archiveWorktreeAfterConfirmation();
+  }, [archiveWorktreeAfterConfirmation]);
 
-  const baseRefLabel = useMemo(() => formatBaseRefLabel(baseRef), [baseRef]);
   const derived = deriveGitActionsState({
     isGit,
     status,
@@ -437,11 +516,6 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     shouldPromoteArchive,
   } = derived;
 
-  const branchLabel = resolveBranchLabel({
-    currentBranch: gitStatus?.currentBranch,
-    notGit,
-  });
-
   const handlePrAction = useCallback(() => {
     if (prStatus?.url) {
       openURLInNewTab(prStatus.url);
@@ -455,12 +529,14 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     return buildGitActions({
       isGit,
       githubFeaturesEnabled,
+      githubAutoMergeActionsEnabled,
       hasPullRequest,
       pullRequestUrl: prStatus?.url ?? null,
       pullRequestState: narrowPullRequestState(prStatus?.state),
       pullRequestIsDraft: prStatus?.isDraft ?? false,
       pullRequestIsMerged: prStatus?.isMerged ?? false,
       pullRequestMergeable: prStatus?.mergeable ?? "UNKNOWN",
+      pullRequestGithub: prStatus?.github ?? null,
       hasRemote,
       isPaseoOwnedWorktree,
       isOnBaseBranch,
@@ -522,6 +598,30 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
           icon: icons.mergePrRebase,
           handler: () => handleMergePr("rebase"),
         },
+        "enable-pr-auto-merge-squash": {
+          disabled: isActionDisabled(actionsDisabled, enablePrAutoMergeStatuses.squash),
+          status: enablePrAutoMergeStatuses.squash,
+          icon: icons.mergePrSquash,
+          handler: () => handleEnablePrAutoMerge("squash"),
+        },
+        "enable-pr-auto-merge-merge": {
+          disabled: isActionDisabled(actionsDisabled, enablePrAutoMergeStatuses.merge),
+          status: enablePrAutoMergeStatuses.merge,
+          icon: icons.mergePrMerge,
+          handler: () => handleEnablePrAutoMerge("merge"),
+        },
+        "enable-pr-auto-merge-rebase": {
+          disabled: isActionDisabled(actionsDisabled, enablePrAutoMergeStatuses.rebase),
+          status: enablePrAutoMergeStatuses.rebase,
+          icon: icons.mergePrRebase,
+          handler: () => handleEnablePrAutoMerge("rebase"),
+        },
+        "disable-pr-auto-merge": {
+          disabled: isActionDisabled(actionsDisabled, disablePrAutoMergeStatus),
+          status: disablePrAutoMergeStatus,
+          icon: icons.viewPr,
+          handler: handleDisablePrAutoMerge,
+        },
         "merge-branch": {
           disabled: isActionDisabled(actionsDisabled, mergeStatus),
           status: mergeStatus,
@@ -551,11 +651,13 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     prStatus?.isDraft,
     prStatus?.isMerged,
     prStatus?.mergeable,
+    prStatus?.github,
     aheadCount,
     behindBaseCount,
     isPaseoOwnedWorktree,
     isOnBaseBranch,
     githubFeaturesEnabled,
+    githubAutoMergeActionsEnabled,
     hasUncommittedChanges,
     aheadOfOrigin,
     behindOfOrigin,
@@ -571,6 +673,10 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     mergePrStatuses.squash,
     mergePrStatuses.merge,
     mergePrStatuses.rebase,
+    enablePrAutoMergeStatuses.squash,
+    enablePrAutoMergeStatuses.merge,
+    enablePrAutoMergeStatuses.rebase,
+    disablePrAutoMergeStatus,
     mergeStatus,
     mergeFromBaseStatus,
     archiveStatus,
@@ -580,6 +686,8 @@ export function useGitActions({ serverId, cwd, icons }: UseGitActionsInput): Use
     handlePullAndPush,
     handlePrAction,
     handleMergePr,
+    handleEnablePrAutoMerge,
+    handleDisablePrAutoMerge,
     handleMergeBranch,
     handleMergeFromBase,
     handleArchiveWorktree,

packages/app/src/git/use-github-search-query.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { buildGithubSearchQueryOptions, githubSearchQueryKey } from "./use-github-search-query";
+
+describe("githubSearchQueryKey", () => {
+  it("keeps the shared cache key shape for no-kinds searches", () => {
+    expect(githubSearchQueryKey("server-1", "/repo", "  123  ")).toEqual([
+      "github-search",
+      "server-1",
+      "/repo",
+      "123",
+    ]);
+  });
+
+  it("adds a deterministic kinds key when kinds are specified", () => {
+    expect(githubSearchQueryKey("server-1", "/repo", "123", ["github-pr", "github-issue"])).toEqual(
+      ["github-search", "server-1", "/repo", "123", "github-issue,github-pr"],
+    );
+  });
+});
+
+describe("buildGithubSearchQueryOptions", () => {
+  it("forwards kinds to the GitHub search request when specified", async () => {
+    const requests: unknown[] = [];
+    const query = buildGithubSearchQueryOptions({
+      client: {
+        async searchGitHub(options) {
+          requests.push(options);
+          return { items: [], githubFeaturesEnabled: true, error: null, requestId: "request-1" };
+        },
+      },
+      serverId: "server-1",
+      cwd: "/repo",
+      query: " 123 ",
+      kinds: ["github-pr"],
+      enabled: true,
+    });
+
+    await query.queryFn();
+
+    expect(requests).toEqual([{ cwd: "/repo", query: "123", limit: 20, kinds: ["github-pr"] }]);
+  });
+});

packages/app/src/git/use-github-search-query.ts

@@ -0,0 +1,64 @@
+import { useQuery } from "@tanstack/react-query";
+import type { GitHubSearchRequest, GitHubSearchResponse } from "@server/shared/messages";
+
+export const GITHUB_SEARCH_STALE_TIME = 30_000;
+
+export type GitHubSearchPayload = GitHubSearchResponse["payload"];
+
+export interface GitHubSearchClient {
+  searchGitHub: (
+    options: {
+      cwd: string;
+      query: string;
+      limit?: number;
+      kinds?: GitHubSearchRequest["kinds"];
+    },
+    requestId?: string,
+  ) => Promise<GitHubSearchPayload>;
+}
+
+interface GitHubSearchQueryInput {
+  client: GitHubSearchClient | null;
+  serverId: string;
+  cwd: string;
+  query: string;
+  kinds?: GitHubSearchRequest["kinds"];
+  enabled: boolean;
+}
+
+export function githubSearchQueryKey(
+  serverId: string,
+  cwd: string,
+  query: string,
+  kinds?: GitHubSearchRequest["kinds"],
+) {
+  const trimmedQuery = query.trim();
+  if (!kinds) {
+    return ["github-search", serverId, cwd, trimmedQuery] as const;
+  }
+  return ["github-search", serverId, cwd, trimmedQuery, [...kinds].sort().join(",")] as const;
+}
+
+export function buildGithubSearchQueryOptions(input: GitHubSearchQueryInput) {
+  const query = input.query.trim();
+
+  return {
+    queryKey: githubSearchQueryKey(input.serverId, input.cwd, query, input.kinds),
+    queryFn: async (): Promise<GitHubSearchPayload> => {
+      if (!input.client) {
+        throw new Error("Host is not connected");
+      }
+      const request = { cwd: input.cwd, query, limit: 20 };
+      if (input.kinds) {
+        return input.client.searchGitHub({ ...request, kinds: input.kinds });
+      }
+      return input.client.searchGitHub(request);
+    },
+    enabled: input.enabled && Boolean(input.client),
+    staleTime: GITHUB_SEARCH_STALE_TIME,
+  };
+}
+
+export function useGithubSearchQuery(input: GitHubSearchQueryInput) {
+  return useQuery(buildGithubSearchQueryOptions(input));
+}

packages/app/src/git/worktree-archive-warning.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildWorktreeArchiveConfirmationMessage,
+  buildWorktreeArchiveRiskReasons,
+} from "@/git/worktree-archive-warning";
+
+describe("worktree archive warning", () => {
+  it("does not require a confirmation for clean and pushed worktrees", () => {
+    expect(
+      buildWorktreeArchiveConfirmationMessage({
+        worktreeName: "feature",
+        isDirty: false,
+        aheadOfOrigin: 0,
+        diffStat: null,
+      }),
+    ).toBeNull();
+  });
+
+  it("explains uncommitted line changes", () => {
+    expect(
+      buildWorktreeArchiveRiskReasons({
+        isDirty: true,
+        aheadOfOrigin: 0,
+        diffStat: { additions: 12, deletions: 1 },
+      }),
+    ).toEqual(["Uncommitted changes (12 added lines, 1 deleted line)"]);
+  });
+
+  it("treats nonzero diff stats as dirty when dirty state is missing", () => {
+    expect(
+      buildWorktreeArchiveRiskReasons({
+        isDirty: undefined,
+        aheadOfOrigin: 0,
+        diffStat: { additions: 4, deletions: 0 },
+      }),
+    ).toEqual(["Uncommitted changes (4 added lines)"]);
+  });
+
+  it("explains unpushed commits", () => {
+    expect(
+      buildWorktreeArchiveRiskReasons({
+        isDirty: false,
+        aheadOfOrigin: 2,
+        diffStat: null,
+      }),
+    ).toEqual(["2 unpushed commits"]);
+  });
+
+  it("includes every archive risk in the confirmation copy", () => {
+    expect(
+      buildWorktreeArchiveConfirmationMessage({
+        worktreeName: "risky-feature",
+        isDirty: true,
+        aheadOfOrigin: 1,
+        diffStat: { additions: 1, deletions: 3 },
+      }),
+    ).toBe("Uncommitted changes (1 added line, 3 deleted lines)\n1 unpushed commit");
+  });
+});

packages/app/src/git/worktree-archive-warning.ts

@@ -0,0 +1,79 @@
+import { confirmDialog } from "@/utils/confirm-dialog";
+
+export interface WorktreeArchiveRisk {
+  isDirty?: boolean | null;
+  aheadOfOrigin?: number | null;
+  diffStat?: { additions: number; deletions: number } | null;
+}
+
+export interface WorktreeArchiveConfirmationInput extends WorktreeArchiveRisk {
+  worktreeName: string;
+}
+
+function pluralize(count: number, singular: string, plural = `${singular}s`): string {
+  return count === 1 ? singular : plural;
+}
+
+function formatDiffStat(diffStat: WorktreeArchiveRisk["diffStat"]): string | null {
+  if (!diffStat) {
+    return null;
+  }
+
+  const parts: string[] = [];
+  if (diffStat.additions > 0) {
+    parts.push(`${diffStat.additions} added ${pluralize(diffStat.additions, "line")}`);
+  }
+  if (diffStat.deletions > 0) {
+    parts.push(`${diffStat.deletions} deleted ${pluralize(diffStat.deletions, "line")}`);
+  }
+
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+
+export function buildWorktreeArchiveRiskReasons(input: WorktreeArchiveRisk): string[] {
+  const reasons: string[] = [];
+  const diffStat = input.diffStat;
+  const hasDiffStatChanges = diffStat ? diffStat.additions > 0 || diffStat.deletions > 0 : false;
+  const hasUncommittedChanges =
+    input.isDirty === true || (input.isDirty == null && hasDiffStatChanges);
+
+  if (hasUncommittedChanges) {
+    const diffStatLabel = formatDiffStat(diffStat);
+    reasons.push(diffStatLabel ? `Uncommitted changes (${diffStatLabel})` : "Uncommitted changes");
+  }
+
+  if ((input.aheadOfOrigin ?? 0) > 0) {
+    const aheadOfOrigin = input.aheadOfOrigin ?? 0;
+    reasons.push(`${aheadOfOrigin} unpushed ${pluralize(aheadOfOrigin, "commit")}`);
+  }
+
+  return reasons;
+}
+
+export function buildWorktreeArchiveConfirmationMessage(
+  input: WorktreeArchiveConfirmationInput,
+): string | null {
+  const reasons = buildWorktreeArchiveRiskReasons(input);
+  if (reasons.length === 0) {
+    return null;
+  }
+
+  return reasons.join("\n");
+}
+
+export async function confirmRiskyWorktreeArchive(
+  input: WorktreeArchiveConfirmationInput,
+): Promise<boolean> {
+  const message = buildWorktreeArchiveConfirmationMessage(input);
+  if (!message) {
+    return true;
+  }
+
+  return await confirmDialog({
+    title: `Archive "${input.worktreeName}"?`,
+    message,
+    confirmLabel: "Archive",
+    cancelLabel: "Cancel",
+    destructive: true,
+  });
+}

packages/app/src/hooks/use-agent-autocomplete.ts

@@ -1,11 +1,16 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { keepPreviousData, useQuery } from "@tanstack/react-query";
 import type { AutocompleteOption } from "@/components/ui/autocomplete";
-import { useAgentCommandsQuery, type DraftCommandConfig } from "./use-agent-commands-query";
+import {
+  useAgentCommandsQuery,
+  type AgentSlashCommand,
+  type DraftCommandConfig,
+} from "./use-agent-commands-query";
 import { orderAutocompleteOptions } from "@/components/ui/autocomplete-utils";
 import { useAutocomplete } from "./use-autocomplete";
 import { useSessionStore } from "@/stores/session-store";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
+import { CLIENT_SLASH_COMMANDS, type ClientSlashCommand } from "@/client-slash-commands";
 import {
   applyFileMentionReplacement,
   findActiveFileMention,
@@ -20,10 +25,13 @@ interface UseAgentAutocompleteInput {
   agentId: string;
   draftConfig?: DraftCommandConfig;
   onAutocompleteApplied?: () => void;
+  onClientSlashCommand?: (command: ClientSlashCommand) => void;
+  canExecuteClientSlashCommand?: boolean;
 }
 
 type AgentAutocompleteOption =
-  | (AutocompleteOption & { type: "command" })
+  | (AutocompleteOption & { type: "client_command"; command: ClientSlashCommand })
+  | (AutocompleteOption & { type: "provider_command" })
   | (AutocompleteOption & {
       type: "workspace_entry";
       entryPath: string;
@@ -47,6 +55,10 @@ interface DirectorySuggestionEntry {
   kind: "file" | "directory";
 }
 
+type AvailableCommand =
+  | { source: "client"; command: ClientSlashCommand }
+  | { source: "provider"; command: AgentSlashCommand };
+
 function normalizeDraftCommandConfig(
   draftConfig?: DraftCommandConfig,
 ): DraftCommandConfig | undefined {
@@ -96,6 +108,28 @@ function mapDirectorySuggestionsToEntries(payload: {
   }));
 }
 
+function mapCommandToOption(entry: AvailableCommand): AgentAutocompleteOption {
+  const command = entry.command;
+  const base = {
+    id: command.name,
+    label: `/${command.name}`,
+    detail: command.argumentHint || undefined,
+    description: command.description,
+    kind: "command" as const,
+  };
+  if (entry.source === "client") {
+    return {
+      ...base,
+      type: "client_command",
+      command: entry.command,
+    };
+  }
+  return {
+    ...base,
+    type: "provider_command",
+  };
+}
+
 type AutocompleteMode = "command" | "file" | null;
 
 function resolveAutocompleteMode(args: {
@@ -170,6 +204,8 @@ export function useAgentAutocomplete(input: UseAgentAutocompleteInput): AgentAut
     agentId,
     draftConfig,
     onAutocompleteApplied,
+    onClientSlashCommand,
+    canExecuteClientSlashCommand,
   } = input;
 
   const showCommandAutocomplete = userInput.startsWith("/") && !userInput.includes(" ");
@@ -277,16 +313,22 @@ export function useAgentAutocomplete(input: UseAgentAutocompleteInput): AgentAut
 
     if (mode === "command") {
       const filterLower = commandFilterQuery.toLowerCase();
-      const matches = commands.filter((cmd) => cmd.name.toLowerCase().includes(filterLower));
+      const providerCommands = commands.map(
+        (command): AvailableCommand => ({ source: "provider", command }),
+      );
+      const availableCommands: AvailableCommand[] = isDraftContext
+        ? providerCommands
+        : [
+            ...CLIENT_SLASH_COMMANDS.map(
+              (command): AvailableCommand => ({ source: "client", command }),
+            ),
+            ...providerCommands,
+          ];
+      const matches = availableCommands.filter((entry) =>
+        entry.command.name.toLowerCase().includes(filterLower),
+      );
       const orderedMatches = orderAutocompleteOptions(matches);
-      return orderedMatches.map((cmd) => ({
-        type: "command" as const,
-        id: cmd.name,
-        label: `/${cmd.name}`,
-        detail: cmd.argumentHint || undefined,
-        description: cmd.description,
-        kind: "command",
-      }));
+      return orderedMatches.map(mapCommandToOption);
     }
 
     if (mode === "file" && activeFileMention) {
@@ -302,12 +344,30 @@ export function useAgentAutocomplete(input: UseAgentAutocompleteInput): AgentAut
     }
 
     return [];
-  }, [activeFileMention, commandFilterQuery, commands, fileSuggestionsQuery.data, isVisible, mode]);
+  }, [
+    activeFileMention,
+    commandFilterQuery,
+    commands,
+    fileSuggestionsQuery.data,
+    isDraftContext,
+    isVisible,
+    mode,
+  ]);
 
   const onSelectOption = useCallback(
     (option: AutocompleteOption) => {
       const selected = option as AgentAutocompleteOption;
-      if (selected.type === "command") {
+      if (
+        selected.type === "client_command" &&
+        selected.command.execution === "immediate" &&
+        canExecuteClientSlashCommand &&
+        onClientSlashCommand
+      ) {
+        onClientSlashCommand(selected.command);
+        return;
+      }
+
+      if (selected.type === "client_command" || selected.type === "provider_command") {
         setUserInput(`/${selected.id} `);
         onAutocompleteApplied?.();
         return;
@@ -321,7 +381,13 @@ export function useAgentAutocomplete(input: UseAgentAutocompleteInput): AgentAut
       setUserInput(nextInput);
       onAutocompleteApplied?.();
     },
-    [onAutocompleteApplied, setUserInput, userInput],
+    [
+      canExecuteClientSlashCommand,
+      onAutocompleteApplied,
+      onClientSlashCommand,
+      setUserInput,
+      userInput,
+    ],
   );
 
   const { selectedIndex, onKeyPress } = useAutocomplete({

packages/app/src/hooks/use-agent-commands-query.ts

@@ -4,7 +4,7 @@ import type { AgentProvider } from "@server/server/agent/agent-sdk-types";
 
 const COMMANDS_STALE_TIME = 60_000; // Commands rarely change, cache for 1 minute
 
-interface AgentSlashCommand {
+export interface AgentSlashCommand {
   name: string;
   description: string;
   argumentHint: string;

packages/app/src/hooks/use-agent-input-draft.ts

@@ -27,6 +27,7 @@ type AttachmentUpdater =
 interface AgentInputDraftComposerOptions {
   initialServerId: string | null;
   initialValues?: CreateAgentInitialValues;
+  initialFeatureValues?: Record<string, unknown>;
   isVisible?: boolean;
   onlineServerIds?: string[];
   lockedWorkingDir?: string;
@@ -229,6 +230,7 @@ export function useAgentInputDraft(input: UseAgentInputDraftInput): AgentInputDr
     modeId: formState.selectedMode,
     modelId: effectiveModelId,
     thinkingOptionId: effectiveThinkingOptionId,
+    initialFeatureValues: composerOptions?.initialFeatureValues,
   });
 
   const commandDraftConfig = useMemo(

packages/app/src/hooks/use-compact-web-viewport-zoom-lock.ts

@@ -0,0 +1,40 @@
+import { useEffect } from "react";
+import { isWeb } from "@/constants/platform";
+
+const COMPACT_WEB_VIEWPORT_CONTENT =
+  "width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no, viewport-fit=cover";
+const DEFAULT_WEB_VIEWPORT_CONTENT = "width=device-width, initial-scale=1, viewport-fit=cover";
+
+export function useCompactWebViewportZoomLock(isCompactLayout: boolean) {
+  useEffect(() => {
+    if (!isWeb) {
+      return;
+    }
+
+    const viewportMeta =
+      document.querySelector<HTMLMetaElement>('meta[name="viewport"]') ??
+      document.createElement("meta");
+    const hadViewportMeta = viewportMeta.parentElement !== null;
+    const previousContent = viewportMeta.getAttribute("content");
+
+    if (!hadViewportMeta) {
+      viewportMeta.name = "viewport";
+      document.head.appendChild(viewportMeta);
+    }
+
+    viewportMeta.setAttribute(
+      "content",
+      isCompactLayout ? COMPACT_WEB_VIEWPORT_CONTENT : DEFAULT_WEB_VIEWPORT_CONTENT,
+    );
+
+    return () => {
+      if (!hadViewportMeta) {
+        viewportMeta.remove();
+        return;
+      }
+      if (previousContent !== null) {
+        viewportMeta.setAttribute("content", previousContent);
+      }
+    };
+  }, [isCompactLayout]);
+}

packages/app/src/hooks/use-draft-agent-features.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useQuery } from "@tanstack/react-query";
 import type { AgentProvider, AgentSessionConfig } from "@server/server/agent/agent-sdk-types";
 import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
@@ -21,14 +21,19 @@ export function useDraftAgentFeatures(input: {
   modeId: string | null | undefined;
   modelId: string | null | undefined;
   thinkingOptionId: string | null | undefined;
+  initialFeatureValues?: Record<string, unknown>;
 }) {
-  const { serverId, provider, cwd, modeId, modelId, thinkingOptionId } = input;
-  const [localFeatureValues, setLocalFeatureValues] = useState<Record<string, unknown>>({});
+  const { serverId, provider, cwd, modeId, modelId, thinkingOptionId, initialFeatureValues } =
+    input;
+  const [localFeatureValues, setLocalFeatureValues] = useState<Record<string, unknown>>(
+    () => initialFeatureValues ?? {},
+  );
   const client = useHostRuntimeClient(serverId ?? "");
   const isConnected = useHostRuntimeIsConnected(serverId ?? "");
   const { preferences, updatePreferences } = useFormPreferences();
   const normalizedCwd = cwd?.trim() || "";
   const normalizedProvider = provider ?? null;
+  const previousProviderRef = useRef<AgentProvider | null>(normalizedProvider);
   const persistedFeatureValues = useMemo(
     () => (provider ? (preferences.providerPreferences?.[provider]?.featureValues ?? {}) : {}),
     [preferences.providerPreferences, provider],
@@ -88,15 +93,25 @@ export function useDraftAgentFeatures(input: {
   }, [availableFeatures, featureValues]);
 
   useEffect(() => {
-    setLocalFeatureValues({});
-  }, [provider]);
+    const previousProvider = previousProviderRef.current;
+    previousProviderRef.current = normalizedProvider;
+    if (previousProvider === null) {
+      return;
+    }
+    if (previousProvider !== normalizedProvider) {
+      setLocalFeatureValues({});
+    }
+  }, [normalizedProvider]);
 
   useEffect(() => {
+    if (availableFeaturesRaw === undefined) {
+      return;
+    }
     const next = pruneFeatureValues(localFeatureValues, availableFeatures);
     if (next !== localFeatureValues) {
       setLocalFeatureValues(next);
     }
-  }, [availableFeatures, localFeatureValues]);
+  }, [availableFeatures, availableFeaturesRaw, localFeatureValues]);
 
   const effectiveFeatureValues = Object.keys(featureValues).length > 0 ? featureValues : undefined;
   const setFeatureValue = useCallback(

packages/app/src/hooks/use-explorer-open-gesture.ts

@@ -3,12 +3,15 @@ import { Gesture } from "react-native-gesture-handler";
 import { Extrapolation, interpolate, runOnJS, useSharedValue } from "react-native-reanimated";
 import { useExplorerSidebarAnimation } from "@/contexts/explorer-sidebar-animation-context";
 import { useSidebarAnimation } from "@/contexts/sidebar-animation-context";
+import { isWeb } from "@/constants/platform";
 
 interface UseExplorerOpenGestureParams {
   enabled: boolean;
   onOpen: () => void;
 }
 
+const MOBILE_WEB_EDGE_SWIPE_WIDTH = 32;
+
 export function useExplorerOpenGesture({ enabled, onOpen }: UseExplorerOpenGestureParams) {
   const {
     translateX,
@@ -56,6 +59,12 @@ export function useExplorerOpenGesture({ enabled, onOpen }: UseExplorerOpenGestu
           const absDeltaX = Math.abs(deltaX);
           const absDeltaY = Math.abs(deltaY);
 
+          // Browser back-swipe owns most of the viewport; keep this gesture on the right edge.
+          if (isWeb && touchStartX.value < windowWidth - MOBILE_WEB_EDGE_SWIPE_WIDTH) {
+            stateManager.fail();
+            return;
+          }
+
           // Fail quickly on rightward or clearly vertical intent.
           if (deltaX >= 10) {
             stateManager.fail();

packages/app/src/hooks/use-ios-hardware-keyboard-submit.test.tsx

@@ -0,0 +1,119 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { act, renderHook } from "@testing-library/react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { useIosHardwareKeyboardSubmit } from "./use-ios-hardware-keyboard-submit";
+import {
+  emitHardwareKeyboardSubmitForTest,
+  resetHardwareKeyboardSubmitForTest,
+  getHardwareKeyboardSubmitEnabledForTest,
+  setHardwareKeyboardSubmitEnabled,
+} from "@/native/ios-hardware-keyboard-submit";
+
+describe("useIosHardwareKeyboardSubmit", () => {
+  beforeEach(() => {
+    resetHardwareKeyboardSubmitForTest();
+  });
+
+  it("submits when the focused composer receives a hardware keyboard submit event", () => {
+    const onSubmit = vi.fn();
+
+    renderHook(() =>
+      useIosHardwareKeyboardSubmit({
+        isEnabled: true,
+        onSubmit,
+      }),
+    );
+
+    act(() => {
+      emitHardwareKeyboardSubmitForTest();
+    });
+
+    expect(onSubmit).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not submit when the composer is blurred", () => {
+    const onSubmit = vi.fn();
+
+    renderHook(() =>
+      useIosHardwareKeyboardSubmit({
+        isEnabled: false,
+        onSubmit,
+      }),
+    );
+
+    act(() => {
+      emitHardwareKeyboardSubmitForTest();
+    });
+
+    expect(onSubmit).not.toHaveBeenCalled();
+    expect(getHardwareKeyboardSubmitEnabledForTest()).toBe(false);
+  });
+
+  it("does not submit while the default send action is disabled", () => {
+    const onSubmit = vi.fn();
+
+    renderHook(() =>
+      useIosHardwareKeyboardSubmit({
+        isEnabled: false,
+        onSubmit,
+      }),
+    );
+
+    act(() => {
+      emitHardwareKeyboardSubmitForTest();
+    });
+
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+
+  it("does not disable native hardware submit when mounted disabled", () => {
+    setHardwareKeyboardSubmitEnabled(true);
+
+    renderHook(() =>
+      useIosHardwareKeyboardSubmit({
+        isEnabled: false,
+        onSubmit: vi.fn(),
+      }),
+    );
+
+    expect(getHardwareKeyboardSubmitEnabledForTest()).toBe(true);
+  });
+
+  it("disables native hardware submit when focus moves away", () => {
+    const onSubmit = vi.fn();
+    const { rerender } = renderHook(
+      ({ isEnabled }) =>
+        useIosHardwareKeyboardSubmit({
+          isEnabled,
+          onSubmit,
+        }),
+      { initialProps: { isEnabled: true } },
+    );
+
+    expect(getHardwareKeyboardSubmitEnabledForTest()).toBe(true);
+
+    rerender({ isEnabled: false });
+
+    expect(getHardwareKeyboardSubmitEnabledForTest()).toBe(false);
+  });
+
+  it("unsubscribes on unmount", () => {
+    const onSubmit = vi.fn();
+    const { unmount } = renderHook(() =>
+      useIosHardwareKeyboardSubmit({
+        isEnabled: true,
+        onSubmit,
+      }),
+    );
+
+    unmount();
+
+    act(() => {
+      emitHardwareKeyboardSubmitForTest();
+    });
+
+    expect(onSubmit).not.toHaveBeenCalled();
+  });
+});

packages/app/src/hooks/use-ios-hardware-keyboard-submit.ts

@@ -0,0 +1,34 @@
+import { useEffect, useRef } from "react";
+import {
+  addHardwareKeyboardSubmitListener,
+  setHardwareKeyboardSubmitEnabled,
+} from "@/native/ios-hardware-keyboard-submit";
+
+interface UseIosHardwareKeyboardSubmitInput {
+  isEnabled: boolean;
+  onSubmit: () => void;
+}
+
+export function useIosHardwareKeyboardSubmit(input: UseIosHardwareKeyboardSubmitInput) {
+  const onSubmitRef = useRef(input.onSubmit);
+
+  useEffect(() => {
+    onSubmitRef.current = input.onSubmit;
+  }, [input.onSubmit]);
+
+  useEffect(() => {
+    if (!input.isEnabled) {
+      return;
+    }
+
+    const subscription = addHardwareKeyboardSubmitListener(() => {
+      onSubmitRef.current();
+    });
+    setHardwareKeyboardSubmitEnabled(true);
+
+    return () => {
+      setHardwareKeyboardSubmitEnabled(false);
+      subscription.remove();
+    };
+  }, [input.isEnabled]);
+}

packages/app/src/hooks/use-pr-pane-data.test.ts

@@ -54,6 +54,24 @@ vi.mock("@/runtime/host-runtime", () => ({
 const cwd = "/repo";
 const serverId = "server-1";
 
+const githubStatus: CheckoutPrStatus["github"] = {
+  mergeStateStatus: null,
+  autoMergeRequest: null,
+  viewerCanEnableAutoMerge: false,
+  viewerCanDisableAutoMerge: false,
+  viewerCanMergeAsAdmin: false,
+  viewerCanUpdateBranch: false,
+  repository: {
+    autoMergeAllowed: false,
+    mergeCommitAllowed: false,
+    squashMergeAllowed: false,
+    rebaseMergeAllowed: false,
+    viewerDefaultMergeMethod: null,
+  },
+  isMergeQueueEnabled: false,
+  isInMergeQueue: false,
+};
+
 function status(overrides: Partial<CheckoutPrStatus> = {}): CheckoutPrStatus {
   return {
     number: 42,
@@ -69,6 +87,7 @@ function status(overrides: Partial<CheckoutPrStatus> = {}): CheckoutPrStatus {
     reviewDecision: null,
     repoOwner: "getpaseo",
     repoName: "paseo",
+    github: githubStatus,
     ...overrides,
   };
 }

packages/app/src/hooks/use-projects.test.ts

@@ -255,6 +255,7 @@ describe("useProjects", () => {
       "hostCount",
       "hosts",
       "onlineHostCount",
+      "projectCustomName",
       "projectKey",
       "projectName",
       "totalWorkspaceCount",

packages/app/src/hooks/use-settings.test.ts

@@ -1,4 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { QueryClient } from "@tanstack/react-query";
 
 const asyncStorageMock = vi.hoisted(() => ({
   getItem: vi.fn<(_: string) => Promise<string | null>>(),
@@ -87,6 +88,7 @@ describe("use-settings", () => {
       manageBuiltInDaemon: true,
       sendBehavior: "interrupt",
       serviceUrlBehavior: "ask",
+      terminalScrollbackLines: 10_000,
       releaseChannel: "stable",
     });
   });
@@ -130,6 +132,7 @@ describe("use-settings", () => {
       theme: "dark",
       sendBehavior: "interrupt",
       serviceUrlBehavior: "ask",
+      terminalScrollbackLines: 10_000,
     });
     expect(asyncStorageMock.setItem).toHaveBeenCalledWith(
       mod.APP_SETTINGS_KEY,
@@ -169,6 +172,7 @@ describe("use-settings", () => {
       theme: "light",
       sendBehavior: "interrupt",
       serviceUrlBehavior: "ask",
+      terminalScrollbackLines: 10_000,
       manageBuiltInDaemon: false,
       releaseChannel: "beta",
     });
@@ -188,8 +192,58 @@ describe("use-settings", () => {
       theme: "light",
       sendBehavior: "interrupt",
       serviceUrlBehavior: "ask",
+      terminalScrollbackLines: 10_000,
       manageBuiltInDaemon: true,
       releaseChannel: "stable",
     });
   });
+
+  it("loads configured terminal scrollback lines from app settings", async () => {
+    asyncStorageMock.getItem.mockResolvedValue(
+      JSON.stringify({
+        terminalScrollbackLines: 42_000,
+      }),
+    );
+
+    const mod = await import("./use-settings");
+    const result = await mod.loadAppSettingsFromStorage();
+
+    expect(result.terminalScrollbackLines).toBe(42_000);
+  });
+
+  it("saves terminal scrollback through app settings persistence", async () => {
+    asyncStorageMock.setItem.mockResolvedValue();
+
+    const mod = await import("./use-settings");
+    asyncStorageMock.getItem.mockResolvedValue(JSON.stringify(mod.DEFAULT_CLIENT_SETTINGS));
+    const queryClient = new QueryClient();
+
+    await mod.saveAppSettings({
+      queryClient,
+      updates: { terminalScrollbackLines: 42_000 },
+    });
+
+    expect(asyncStorageMock.setItem).toHaveBeenLastCalledWith(
+      mod.APP_SETTINGS_KEY,
+      JSON.stringify({
+        ...mod.DEFAULT_CLIENT_SETTINGS,
+        terminalScrollbackLines: 42_000,
+      }),
+    );
+  });
+
+  it("normalizes terminal scrollback lines from storage", async () => {
+    asyncStorageMock.getItem.mockResolvedValue(
+      JSON.stringify({
+        terminalScrollbackLines: 1_000_000.9,
+      }),
+    );
+
+    const mod = await import("./use-settings");
+    const result = await mod.loadAppSettingsFromStorage();
+
+    expect(result.terminalScrollbackLines).toBe(1_000_000);
+    expect(mod.parseTerminalScrollbackLines("-10")).toBe(0);
+    expect(mod.parseTerminalScrollbackLines("abc")).toBeNull();
+  });
 });