fix(app): preserve scroll ownership through momentum

fix(app): keep chat scrollable during streaming
Continuous Android stream updates kept bottom-anchor verification pending, so genuine finger drags were mistaken for programmatic corrections. Preserve explicit drag ownership so user scrolling can detach immediately.
2026-10-28 20:22:45 +00:00 · 2026-07-23 01:04:00 +02:00 · 2026-07-23 00:35:08 +02:00 · 2026-07-22 21:34:34 +00:00 · 2026-07-22 23:26:47 +02:00 · 2026-07-22 22:46:24 +02:00
630 changed files with 45834 additions and 12933 deletions
@@ -87,6 +87,9 @@
    {
      "files": ["packages/app/src/**/*.{ts,tsx}"],
      "rules": {
+        // React Native style arrays must read Unistyles proxies during render. Hoisting them to
+        // satisfy this allocation rule captures the temporary startup theme instead.
+        "react-perf/jsx-no-new-array-as-prop": "off",
        "no-restricted-imports": [
          "error",
          {
@@ -1,5 +1,65 @@
 # Changelog

+## 0.2.0-beta.3 - 2026-07-22
+
+### Added
+
+- Open the complete Changes view as a workspace tab ([#2298](https://github.com/getpaseo/paseo/pull/2298) by [@nikuscs](https://github.com/nikuscs))
+- Add files to chat directly from Files and Changes ([#2275](https://github.com/getpaseo/paseo/pull/2275) by [@nikuscs](https://github.com/nikuscs))
+- Open existing agents from Paseo links or the CLI ([#2324](https://github.com/getpaseo/paseo/pull/2324))
+- Use Oh My Pi's Write Approval mode to allow reads while requiring approval for changes ([#2228](https://github.com/getpaseo/paseo/pull/2228) by [@theslava](https://github.com/theslava))
+
+### Improved
+
+- Usage bars now warn as provider limits approach ([#2322](https://github.com/getpaseo/paseo/pull/2322) by [@cleiter](https://github.com/cleiter))
+- Oh My Pi advisor results now retain their structure and severity ([#2219](https://github.com/getpaseo/paseo/pull/2219) by [@ebg1223](https://github.com/ebg1223))
+
+### Fixed
+
+- Notifications now open the correct workspace and agent ([#2331](https://github.com/getpaseo/paseo/pull/2331))
+- Archived agents can be restored directly from History ([#2316](https://github.com/getpaseo/paseo/pull/2316))
+- CLI agent runs stay in the current workspace unless a new workspace is requested ([#2315](https://github.com/getpaseo/paseo/pull/2315))
+- Oh My Pi slash commands now include commands from every supported source ([#2175](https://github.com/getpaseo/paseo/pull/2175) by [@bendavid](https://github.com/bendavid))
+- Oh My Pi chats no longer stay stuck as running after delayed or incomplete completion events ([#2261](https://github.com/getpaseo/paseo/pull/2261), [#2282](https://github.com/getpaseo/paseo/pull/2282) by [@isac322](https://github.com/isac322))
+
+## 0.2.0-beta.2 - 2026-07-22
+
+### Added
+
+- Edit files directly in the web and desktop apps ([#2270](https://github.com/getpaseo/paseo/pull/2270), [#2309](https://github.com/getpaseo/paseo/pull/2309))
+- Switch models from the Command Center for active agents and new drafts ([#2147](https://github.com/getpaseo/paseo/pull/2147) by [@kedrzu](https://github.com/kedrzu))
+- Configure workspace service ports with a fixed range or external allocator ([#2165](https://github.com/getpaseo/paseo/pull/2165) by [@mcowger](https://github.com/mcowger))
+- Search keyboard shortcuts by action, note, or key combination ([#2160](https://github.com/getpaseo/paseo/pull/2160))
+- Turn thinking off for supported Claude models ([#2257](https://github.com/getpaseo/paseo/pull/2257))
+- Use Pi's Max thinking level ([#2267](https://github.com/getpaseo/paseo/pull/2267) by [@ByteTrue](https://github.com/ByteTrue))
+
+### Improved
+
+- Improved parity of CLI and MCP tools for workspace, agent and schedule management ([#2186](https://github.com/getpaseo/paseo/pull/2186))
+- Pasted PR/MR links in the composer become auto-selected as a checkout option ([#2290](https://github.com/getpaseo/paseo/pull/2290))
+- Projects, workspaces and chat syncing is more efficient ([#2028](https://github.com/getpaseo/paseo/pull/2028), [#2185](https://github.com/getpaseo/paseo/pull/2185), [#2196](https://github.com/getpaseo/paseo/pull/2196), [#2206](https://github.com/getpaseo/paseo/pull/2206), [#2259](https://github.com/getpaseo/paseo/pull/2259), [#2263](https://github.com/getpaseo/paseo/pull/2263))
+- Make project creation more explicit ([#2098](https://github.com/getpaseo/paseo/pull/2098), [#2187](https://github.com/getpaseo/paseo/pull/2187))
+- Idle agents release processes automatically and resume when needed ([#2203](https://github.com/getpaseo/paseo/pull/2203), [#2209](https://github.com/getpaseo/paseo/pull/2209))
+- New Claude and Codex agents default to safer automatic approval modes when supported ([#2213](https://github.com/getpaseo/paseo/pull/2213))
+- Oh My Pi now supports Max thinking in imported and new sessions ([#2191](https://github.com/getpaseo/paseo/pull/2191) by [@mvanhorn](https://github.com/mvanhorn))
+- Commit history now includes recent pushed and base-branch commits ([#2312](https://github.com/getpaseo/paseo/pull/2312))
+- Permission and thinking changes made during a turn now show when they take effect ([#2201](https://github.com/getpaseo/paseo/pull/2201))
+
+### Fixed
+
+- Reused branches no longer attach an unrelated merged or closed pull request ([#2172](https://github.com/getpaseo/paseo/pull/2172) by [@nllptrx](https://github.com/nllptrx))
+- Pi compaction waits for long summaries instead of reporting a false timeout ([#2181](https://github.com/getpaseo/paseo/pull/2181) by [@jasonhnd](https://github.com/jasonhnd))
+- Pi chats keep new messages aligned with the correct history after an idle agent resumes ([#2313](https://github.com/getpaseo/paseo/pull/2313))
+- OpenCode follow-ups triggered by completed background work now remain visible ([#2258](https://github.com/getpaseo/paseo/pull/2258))
+- Codex no longer shows the parent agent as a phantom subagent ([#2214](https://github.com/getpaseo/paseo/pull/2214))
+- Local dictation now works in Nix-packaged installations ([#1587](https://github.com/getpaseo/paseo/pull/1587) by [@yhori991](https://github.com/yhori991))
+- The composer remains visible after submitting dictated text and returning to the app ([#2194](https://github.com/getpaseo/paseo/pull/2194))
+- Desktop's dictation shortcut remains responsive after finishing a recording ([#2268](https://github.com/getpaseo/paseo/pull/2268))
+- Projects can be renamed before their first workspace ([#2252](https://github.com/getpaseo/paseo/pull/2252) by [@albertodeago](https://github.com/albertodeago))
+- Settings keep showing a connected remote host when the local daemon is stopped ([#1749](https://github.com/getpaseo/paseo/pull/1749) by [@dwyanewang](https://github.com/dwyanewang))
+- Pinned workspaces no longer disappear briefly when reopening the compact sidebar ([#2210](https://github.com/getpaseo/paseo/pull/2210))
+- Session imports find older matches from the current workspace ([#2265](https://github.com/getpaseo/paseo/pull/2265) by [@nikuscs](https://github.com/nikuscs))
+
 ## 0.2.0-beta.1 - 2026-07-17

 ### Added
@@ -10,7 +10,26 @@ initializing → idle → running → idle (or error → closed)
                 └────────┘  (agent completes a turn, awaits next prompt)
 ```

-Each agent in `AgentManager` carries a `lastStatus` of `initializing`, `idle`, `running`, `error`, or `closed`. State transitions persist to disk and stream to subscribed clients via WebSocket.
+Each live agent in `AgentManager` carries a `lastStatus` of `initializing`, `idle`, `running`, or `error`. `closed` is the persisted, resumable state for an agent record that has no live provider runtime. State transitions persist to disk and stream to subscribed clients via WebSocket.
+
+## Runtime residency
+
+An unarchived agent may be `closed` without being deleted or archived. Closing releases its provider
+processes and subscriptions while retaining its Paseo identity, persistence handle, timeline,
+workspace, labels, title, usage, attention, timestamps, and parent relationship. Opening or prompting
+the agent runs through `ensureAgentLoaded()`, which resumes the durable provider session under the
+same Paseo agent ID. Provider history is not appended again when the canonical timeline is already
+primed.
+
+The daemon collects an eligible idle runtime after two minutes and sweeps every 15 seconds. Only
+unarchived, non-internal agents that are exactly `idle`, have no active or pending run, replacement,
+or permission, and have not been activated during the idle window are eligible. `running`,
+`initializing`, and `error` agents stay resident. Subagents are considered independently; collection
+does not cascade or change parentage.
+
+Active schedules targeting an existing agent protect that agent from collection. Paused, completed,
+and new-agent schedules do not. A pane may remain open after collection; its next prompt resumes the
+runtime.

 ### Cancellation

@@ -18,21 +37,14 @@ Cancellation changes lifecycle state only after the provider acknowledges the in

 ## Relationships

-Agents can launch other agents via the agent-scoped `create_agent` MCP tool. Agent-scoped creation is always asynchronous. `relationship` and `workspace` are separate decisions:
-
- `relationship` decides whether the new agent belongs under the caller.
- `workspace` decides where the new agent lives and whether a new workspace/worktree is created.
-
-`relationship: { kind: "subagent" }` stamps the created agent with `paseo.parent-agent-id`, pointing back at the creating agent. The client surfaces that as `agent.parentAgentId`. This requires an agent-scoped MCP session.
-
-`relationship: { kind: "detached" }` creates a sibling/root agent (e.g. handoffs, fire-and-forget delegations). The daemon may still use the creating agent for cwd/config inheritance, but it does not write `paseo.parent-agent-id`.
+Agents can launch other agents via the agent-scoped `create_agent` MCP tool. Agent-scoped creation is always asynchronous and always stamps `paseo.parent-agent-id`, pointing back at the caller. Omit `workspaceId` to use the caller's workspace, or pass an existing workspace ID returned by `create_workspace`. Placement never changes parentage.

 - **Subagents** — exist as part of the creating agent's work, appear in that agent's subagent track, and are archived with it.
- **Detached agents** — stand on their own, do not appear in the creating agent's subagent track, and are not archived with it.
+- **Detached agents** — stand on their own after an explicit detach transition, do not appear in the former parent's subagent track, and are not archived with it.

-`workspace: { kind: "current" }` uses the caller's workspace and can optionally override the runtime cwd. It requires an agent-scoped MCP session. `workspace: { kind: "create", source: { kind: "directory" | "worktree", ... } }` creates a new workspace for the new agent; worktree creation goes through the Paseo worktree workflow and stamps the agent with that fresh workspace id.
+Runtime ownership is resolved from explicit workspace ID and caller context, never from `cwd`. Workspace creation is a separate operation with `local | worktree` isolation; agent creation only selects an existing workspace.

-Users can also detach an existing subagent from the subagents track. Detach removes the `paseo.parent-agent-id` label only: it does not stop, archive, move, or restart the agent. The agent keeps its current `cwd` and `workspaceId`, leaves the former parent's track, and behaves like a root agent for tab close, workspace activity, and future parent archive.
+Users can also detach an existing subagent from the subagents track. Detach is deliberately a manual lifecycle gesture, not an agent-facing MCP tool. It removes the `paseo.parent-agent-id` label only: it does not stop, archive, move, or restart the agent. The agent keeps its current `cwd` and `workspaceId`, leaves the former parent's track, and behaves like a root agent for tab close, workspace activity, and future parent archive.

 `notifyOnFinish` defaults to `true` for agent-scoped creation and background prompt follow-ups because most delegated work needs to report back to the creating agent. Set it to `false` only for truly fire-and-forget agents or prompts.

@@ -46,7 +58,11 @@ The provider still owns the underlying runtime. Paseo keeps an agent record so t

 Archive is a **soft delete**: the agent record stays on disk with `archivedAt` set, the runtime is closed, and the agent disappears from active lists. Archive is **global** — it lives on the server and propagates to every connected client.

-`create_agent_request` can opt an agent into `autoArchive`. In that mode the daemon archives the agent after the first terminal turn event (`turn_completed`, `turn_failed`, or `turn_canceled`). If the same request created a Paseo worktree through its `worktree` field, auto-archive archives that worktree too, which removes the agent records inside the worktree.
+Archive is distinct from runtime collection. Archive sets `archivedAt`, invokes the provider's native
+archive hook, and cascades to managed children. Runtime collection does none of those things; it only
+releases the live runtime and writes `lastStatus: closed` on the still-active record.
+
+`create_agent_request` can opt an agent into `autoArchive`. In that mode the daemon archives the agent after the first terminal turn event (`turn_completed`, `turn_failed`, or `turn_canceled`). When the agent owns an isolated workspace, auto-archive archives that workspace too; the managed worktree is removed when its final workspace reference is gone.

 Archiving runs through `AgentManager.archiveAgent` (`packages/server/src/server/agent/agent-manager.ts`):

@@ -64,6 +80,13 @@ archived workspace. History navigation must not infer workspace lifecycle from `
 or mutate either lifecycle. The workspace route asks the daemon for authoritative recovery state;
 only the route's explicit Unarchive or Restore action changes the archived workspace.

+History navigation preserves the selected agent as an explicit recovery target. If both that agent
+and its workspace are archived, the workspace recovery action restores the workspace and unarchives
+the selected agent as one user action. Other archived agents in the restored workspace remain
+recoverable from History. Opening one pins its tab and renders the archived-agent callout before any
+provider timeline is loaded; **Unarchive** runs the provider's native unarchive hook (including Codex
+`thread/unarchive`) before the normal agent resume and timeline hydration flow.
+
 ## Tabs vs archive

 These are two distinct concepts that used to be conflated:
@@ -139,11 +162,11 @@ $PASEO_HOME/agents/{cwd-with-dashes}/{agent-id}.json

 Each agent is a single JSON file. Fields relevant to this doc:

-| Field                             | Type          | Meaning                                                                                      |
-| --------------------------------- | ------------- | -------------------------------------------------------------------------------------------- |
-| `id`                              | `string`      | Stable identifier                                                                            |
-| `archivedAt`                      | `string?`     | Soft-delete timestamp (ISO 8601)                                                             |
-| `labels["paseo.parent-agent-id"]` | `string?`     | Parent agent ID, set automatically by `create_agent` when `relationship.kind === "subagent"` |
-| `lastStatus`                      | `AgentStatus` | `initializing` / `idle` / `running` / `error` / `closed`                                     |
+| Field                             | Type          | Meaning                                                                            |
+| --------------------------------- | ------------- | ---------------------------------------------------------------------------------- |
+| `id`                              | `string`      | Stable identifier                                                                  |
+| `archivedAt`                      | `string?`     | Soft-delete timestamp (ISO 8601)                                                   |
+| `labels["paseo.parent-agent-id"]` | `string?`     | Parent agent ID, set automatically for agent-scoped creation and removed by detach |
+| `lastStatus`                      | `AgentStatus` | `initializing` / `idle` / `running` / `error` / `closed`                           |

 See [`docs/data-model.md`](./data-model.md) for the full agent record.
@@ -122,6 +122,8 @@ The flag must be present for both prebuild and Gradle because Gradle starts Metr

 Keep the excluded npm packages installed. Normal builds use them, while the F-Droid profile removes only their Android native modules and config plugins. Paseo always applies `expo-gradle-jvmargs` with `-Xmx4096m` and `-XX:MaxMetaspaceSize=1024m` so local Expo prebuilds have enough Gradle heap whether they use precompiled AARs or source-built Expo modules.

+The EAS `production-apk` profile uses the large Android resource class. Release builds compile the native ABIs and run Hermes bundling in the same Gradle invocation; the default worker can exhaust its remaining memory and kill Hermes with exit code 137 even when Gradle's own heap is correctly sized.
+
 ### React version lockstep

 Keep `react` and `react-dom` pinned to the React version embedded by the current `react-native` release. React Native `0.81.x` embeds `react-native-renderer` `19.1.0`, so `packages/app` must use React `19.1.0`. Bumping React to a newer patch can build successfully but crash at JS startup on Android with `Incompatible React versions`, leaving the app on the native splash screen.
@@ -54,22 +54,30 @@ The heart of Paseo. A Node.js process that:

 All paths are under `packages/server/src/`.

+Project identity is daemon-global rather than session-owned. After registry bootstrap, the daemon's
+project Git observer keeps one non-recursive watch on each lexically equivalent active project root
+and listens only for the root `.git` entry, with a slow rescan as a missed-event fallback. It runs
+for empty projects and without connected clients, then fans metadata changes through the WebSocket
+server to capability-aware sessions. It deliberately does not use the broad recursive working-tree
+watcher or the per-session Git observer: those are checkout/status mechanisms and intentionally do
+not retain non-Git directories.
+
 **Key modules:**

-| Module                          | Responsibility                                                               |
-| ------------------------------- | ---------------------------------------------------------------------------- |
-| `server/bootstrap.ts`           | Daemon initialization: HTTP server, WS server, agent manager, storage, relay |
-| `server/websocket-server.ts`    | WebSocket connection management, hello handshake, binary frame routing       |
-| `server/session.ts`             | Per-client session state, timeline subscriptions, terminal operations        |
-| `server/agent/agent-manager.ts` | Agent lifecycle state machine, timeline tracking, subscriber management      |
-| `server/agent/agent-storage.ts` | File-backed JSON persistence at `$PASEO_HOME/agents/`                        |
-| `server/agent/tools/`           | Transport-neutral Paseo tool catalog for subagents, permissions, worktrees   |
-| `server/agent/mcp-server.ts`    | Thin MCP adapter that registers the Paseo tool catalog with the MCP SDK      |
-| `server/agent/providers/`       | Provider adapters (see "Agent providers" below)                              |
-| `server/relay-transport.ts`     | Outbound relay connection with E2E encryption                                |
-| `server/schedule/`              | Cron-based scheduled agents                                                  |
-| `server/loop-service.ts`        | Looping agent runs that retry until an exit condition                        |
-| `server/chat/`                  | Chat rooms for agent-to-agent and human-to-agent messaging                   |
+| Module                          | Responsibility                                                                |
+| ------------------------------- | ----------------------------------------------------------------------------- |
+| `server/bootstrap.ts`           | Daemon initialization: HTTP server, WS server, agent manager, storage, relay  |
+| `server/websocket-server.ts`    | WebSocket connection management, hello handshake, binary frame routing        |
+| `server/session.ts`             | Per-client session state, timeline subscriptions, terminal operations         |
+| `server/agent/agent-manager.ts` | Agent lifecycle state machine, timeline tracking, subscriber management       |
+| `server/agent/agent-storage.ts` | File-backed JSON persistence at `$PASEO_HOME/agents/`                         |
+| `server/agent/tools/`           | Transport-neutral catalog for workspaces, agents, permissions, and automation |
+| `server/agent/mcp-server.ts`    | Thin MCP adapter that registers the Paseo tool catalog with the MCP SDK       |
+| `server/agent/providers/`       | Provider adapters (see "Agent providers" below)                               |
+| `server/relay-transport.ts`     | Outbound relay connection with E2E encryption                                 |
+| `server/schedule/`              | Cron-based scheduled agents                                                   |
+| `server/loop-service.ts`        | Looping agent runs that retry until an exit condition                         |
+| `server/chat/`                  | Chat rooms for agent-to-agent and human-to-agent messaging                    |

 ### `packages/protocol` — Wire schemas and shared protocol types

@@ -89,14 +97,22 @@ code imports from `@getpaseo/client`.

 Cross-platform React Native app that connects to one or more daemons.

- Expo Router navigation (`/h/[serverId]/workspace/[workspaceId]`, `/h/[serverId]/agent/[agentId]`, etc.). The `workspaceId` URL segment is an opaque workspace id (path-shaped today and opaque-encoded for routing), not a directly meaningful filesystem path.
+- Expo Router navigation (`/h/[serverId]/workspace/[workspaceId]`, `/h/[serverId]/agent/[agentId]`, etc.). The `workspaceId` URL segment is an opaque workspace id, not a directly meaningful filesystem path.
 - `HostRuntimeController` manages saved host connections, reconnection, and per-host runtime state
+- `runtime/replica-cache` keeps a non-authoritative per-host display replica in AsyncStorage: only the last focused agent, its workspace, and a short timeline tail. It restores before navigation becomes ready, leaves remote hydration flags false, and is atomically replaced by the normal snapshot-plus-delta synchronization path.
 - `SessionContext` wraps the daemon client for the active session
 - Composer UI and submit/draft behavior live in `packages/app/src/composer/`; screens and panels should integrate it from there instead of dropping composer internals into `components/`, `hooks/`, or `screens/workspace/`
 - Timeline reducers in `timeline/session-stream-reducers.ts` handle compaction, gap detection, sequence-based deduplication
 - Timeline sync correctness is documented in [docs/timeline-sync.md](timeline-sync.md): live streams are for immediacy, `fetch_agent_timeline_request` is authoritative, and catch-up is paged but complete.
 - Voice features: dictation (STT) and voice agent (realtime)

+The replica cache exists only to paint stale data immediately while the host connects. It does not
+own mutations, infer deletions, or replace daemon reconciliation. Pending permission requests are
+not restored from it. AsyncStorage is not encrypted, so the cached timeline tail may contain source
+code, prompts, and tool output; encrypted-at-rest storage is a separate product/security decision.
+Its serialized payload has a 1 MiB byte budget and evicts whole host snapshots in least-recently-
+written order; a single oversized host is omitted rather than partially restored.
+
 ### `packages/cli` — Command-line client

 Commander.js CLI with Docker-style commands. Common agent operations are also exposed at the top level (e.g. `paseo ls`, `paseo run`).
@@ -107,9 +123,11 @@ Commander.js CLI with Docker-style commands. Common agent operations are also ex
 - `paseo terminal ls/create/capture/send-keys/kill`
 - `paseo loop run/ls/inspect/logs/stop`
 - `paseo schedule create/ls/inspect/update/pause/resume/run-once/logs/delete`
+- `paseo heartbeat create/update/delete`
+- `paseo workspace create/ls/archive`
 - `paseo permit allow/deny/ls`
 - `paseo provider ls/models`
- `paseo worktree create/ls/archive`
+- hidden legacy `paseo worktree create/ls/archive` compatibility alias
 - `paseo speech …`

 Communicates with the daemon via the same WebSocket protocol as the app.
@@ -126,6 +144,11 @@ Enables remote access when the daemon is behind a firewall.

 See [SECURITY.md](../SECURITY.md) for the full threat model.

+### Paseo Hub
+
+The optional Hub relationship is daemon-outbound and does not use the relay. Its connection,
+authorization, ownership, persistence, and lifecycle contract is documented in [hub.md](hub.md).
+
 ### `packages/desktop` — Desktop app (Electron)

 Electron wrapper for macOS, Linux, and Windows.
@@ -1,5 +1,29 @@
 # Data Model

+## Project identity
+
+Projects are allocated for the exact root selected by the caller, normalized lexically with `path.resolve` (never `realpath`). New project IDs are opaque `prj_<16 hex>` values. Existing remote-shaped or path-shaped IDs are retained as readable compatibility records and are never rekeyed. An active exact root is idempotent; archived-only matches do not resurrect an old project. Workspace `projectId` is stable membership: reconciliation may update git-derived kind and branch metadata, but never rehomes a workspace or changes a project's root, ID, or default name.
+
+`kind` is mutable metadata, not identity. Workspace reconciliation watches active project roots and
+updates only a project's `kind` and `updatedAt` when `.git` appears or disappears, preserving its
+ID, root path, names, and workspace foreign keys. Attached workspaces are independently refreshed
+from their own cwd, so an explicit project root never implies a workspace checkout. Empty projects
+are observed too.
+
+The workspace registry model defines placement once: initial directory/worktree construction,
+mutable reconciliation fields, and the persisted-to-wire checkout projection. Its update policy
+preserves `displayName` and `baseBranch`. `WorkspaceProvisioningService` owns the corresponding
+registry writes, so directory opens, agent imports, and worktree creation all enter through that
+service instead of constructing records independently. The workspace record is then the durable
+placement authority: `cwd` is the exact execution directory, while `worktreeRoot` is the backing
+checkout root. They intentionally differ for an exact subproject inside a worktree. Archive,
+restore, branch auto-name, and descriptor flows consume those persisted facts rather than
+rediscovering ownership from a directory that may already be gone. Reconciliation may refresh
+mutable placement facts, but never changes `projectId`, `cwd`, `displayName`, or `baseBranch`.
+Workspace archive runs lifecycle teardown from the exact `cwd` but removes only the backing
+`worktreeRoot` after its last active reference disappears. Worktree recovery recreates that backing
+checkout from `mainRepoRoot`, then restores the relative path from `worktreeRoot` to `cwd`.
+
 Paseo uses **file-based JSON persistence** instead of a traditional database. All data is validated at runtime with Zod schemas. Most stores write atomically (write to temp file, then rename); a few still use plain `writeFile` — see each section. There is no schema-versioning/migration framework — schemas rely on optional fields with defaults for forward compatibility, with a small amount of inline normalization in `persisted-config.ts` for legacy provider/speech entries.

 All server-side stores live under `$PASEO_HOME` (defaults to `~/.paseo`).
@@ -58,8 +82,8 @@ Each agent is stored as a separate JSON file, grouped by project directory.
 | `lastActivityAt`     | `string?` (ISO 8601)                     | Last activity timestamp                                                                                                                                                                                                                                                                                                                                                             |
 | `lastUserMessageAt`  | `string?` (ISO 8601)                     | Last user message timestamp                                                                                                                                                                                                                                                                                                                                                         |
 | `title`              | `string?`                                | User-visible title                                                                                                                                                                                                                                                                                                                                                                  |
-| `labels`             | `Record<string, string>`                 | Key-value labels (default `{}`). `paseo.parent-agent-id` is set automatically for `create_agent` subagent relationships — see [agent-lifecycle.md](./agent-lifecycle.md)                                                                                                                                                                                                            |
-| `lastStatus`         | `AgentStatus`                            | One of: `"initializing"`, `"idle"`, `"running"`, `"error"`, `"closed"`                                                                                                                                                                                                                                                                                                              |
+| `labels`             | `Record<string, string>`                 | Key-value labels (default `{}`). `paseo.parent-agent-id` is set automatically for agent-scoped creation and removed by detach — see [agent-lifecycle.md](./agent-lifecycle.md)                                                                                                                                                                                                      |
+| `lastStatus`         | `AgentStatus`                            | One of: `"initializing"`, `"idle"`, `"running"`, `"error"`, `"closed"`. `closed` means the record is resumable but has no live provider runtime; archive remains represented separately by `archivedAt`.                                                                                                                                                                            |
 | `lastModeId`         | `string?`                                | Last active mode ID                                                                                                                                                                                                                                                                                                                                                                 |
 | `config`             | `SerializableConfig?`                    | Agent session configuration (see below)                                                                                                                                                                                                                                                                                                                                             |
 | `runtimeInfo`        | `RuntimeInfo?`                           | Live runtime state (see below)                                                                                                                                                                                                                                                                                                                                                      |
@@ -166,6 +190,10 @@ Single file, validated with `PersistedConfigSchema`.
  },
  worktrees?: {
    root?: string            // optional root for new worktrees; defaults to $PASEO_HOME/worktrees
+    servicePorts?: {         // optional dynamic service port allocation policy
+      range?: string         // inclusive range, e.g. "3000-4000"
+      portScript?: string    // executable that receives service/workspace context and prints one TCP port
+    }
  },
  providers: {
    openai: {
@@ -265,8 +293,8 @@ One file per schedule. ID is 8 hex characters.

 ### Nested: ScheduleCadence (discriminated union on `type`)

- `{ type: "every", everyMs: number }` — interval in milliseconds
- `{ type: "cron", expression: string, timezone?: string }` — cron expression; absent `timezone` means UTC, present `timezone` is an IANA time zone used for local wall-clock recurrence
+- `{ type: "cron", expression: string, timezone?: string }` — canonical cadence for new writes; absent `timezone` means UTC
+- `{ type: "every", everyMs: number }` — legacy rolling interval, still readable and executable during the compatibility window

 ### Nested: ScheduleTarget (discriminated union on `type`)

@@ -422,19 +450,22 @@ Array of project records.

 | Field         | Type                        | Description                                                                      |
 | ------------- | --------------------------- | -------------------------------------------------------------------------------- |
-| `projectId`   | `string`                    | Primary key                                                                      |
-| `rootPath`    | `string`                    | Filesystem root of the project                                                   |
-| `kind`        | `"git" \| "non_git"`        |                                                                                  |
-| `displayName` | `string`                    |                                                                                  |
+| `projectId`   | `string`                    | Primary key; new records use opaque `prj_<16 hex>` IDs                           |
+| `rootPath`    | `string`                    | Exact lexically normalized selected root; never realpathed                       |
+| `kind`        | `"git" \| "non_git"`        | Mutable Git observation about `rootPath`, never a membership key                 |
+| `displayName` | `string`                    | Selected-root basename, stable across remote and Git changes                     |
 | `customName`  | `string \| null`            | User-set override layered over `displayName`. Null means "use the derived name". |
 | `createdAt`   | `string` (ISO 8601)         |                                                                                  |
 | `updatedAt`   | `string` (ISO 8601)         |                                                                                  |
 | `archivedAt`  | `string \| null` (ISO 8601) | Soft-delete timestamp; required nullable                                         |

-Active git projects are unique by normalized `rootPath`. Startup reconciliation repairs older bad
-states by moving workspaces from duplicate path-keyed projects onto the canonical project,
-preferring remote-keyed project IDs such as `remote:github.com/owner/repo`, then archiving the
-emptied duplicate.
+Active exact roots are idempotent using lexical platform-equivalence semantics. Existing legacy
+remote-shaped and path-shaped IDs remain readable, including duplicate roots; reconciliation never
+merges them, transfers names, archives them, or moves workspace foreign keys. An explicit
+workspace `projectId` is authoritative when it names an active project, regardless of cwd
+containment. Archived-only exact-root records are not resurrected by explicit add/open; a fresh
+opaque project is allocated instead. Agent restore is separate and restores the agent's existing
+workspace together with its owning project.

 ---

@@ -444,21 +475,25 @@ emptied duplicate.

 Array of workspace records. A workspace is a specific working directory within a project.

-| Field         | Type                                            | Description                                                                                                                                                                           |
-| ------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `workspaceId` | `string`                                        | Opaque stable identifier (`wks_<hex>`), generated independently of the directory. MUST NOT be treated as a path; compare by exact equality. Use the `cwd` field for directory access. |
-| `projectId`   | `string`                                        | FK to Project.projectId                                                                                                                                                               |
-| `cwd`         | `string`                                        | Filesystem path                                                                                                                                                                       |
-| `kind`        | `"local_checkout" \| "worktree" \| "directory"` |                                                                                                                                                                                       |
-| `displayName` | `string`                                        | The human name (the generated/derived title). Decoupled from `branch` by construction.                                                                                                |
-| `title`       | `string \| null`                                | User-set name override layered over `displayName`. Null means "use `displayName`".                                                                                                    |
-| `branch`      | `string \| null`                                | The worktree's git branch. Separate from `displayName`/`title`; only worktree workspaces set it. A branch rename writes this and never the name.                                      |
-| `createdAt`   | `string` (ISO 8601)                             |                                                                                                                                                                                       |
-| `updatedAt`   | `string` (ISO 8601)                             |                                                                                                                                                                                       |
-| `archivedAt`  | `string \| null` (ISO 8601)                     | Soft-delete; required nullable                                                                                                                                                        |
-| `pinnedAt`    | `string \| null` (ISO 8601)                     | Pinned-to-top-of-sidebar timestamp; null means "not pinned"                                                                                                                           |
+| Field                  | Type                                            | Description                                                                                                                                                                           |
+| ---------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `workspaceId`          | `string`                                        | Opaque stable identifier (`wks_<hex>`), generated independently of the directory. MUST NOT be treated as a path; compare by exact equality. Use the `cwd` field for directory access. |
+| `projectId`            | `string`                                        | FK to Project.projectId; the workspace's stable project membership                                                                                                                    |
+| `cwd`                  | `string`                                        | Exact execution directory selected for agents, files, scripts, and setup                                                                                                              |
+| `kind`                 | `"local_checkout" \| "worktree" \| "directory"` | Mutable checkout classification                                                                                                                                                       |
+| `displayName`          | `string`                                        | The human name (the generated/derived title). Decoupled from `branch` by construction.                                                                                                |
+| `title`                | `string \| null`                                | User-set name override layered over `displayName`. Null means "use `displayName`".                                                                                                    |
+| `branch`               | `string \| null`                                | The current Git branch for git-backed workspaces. Separate from `displayName`/`title`; a background branch refresh never rewrites the name.                                           |
+| `worktreeRoot`         | `string \| null`                                | Backing checkout/worktree root. May differ from `cwd` for exact subprojects and remains persisted after the worktree is deleted so restore can reproduce the placement.               |
+| `baseBranch`           | `string \| null`                                | Normalized branch the Paseo worktree was created from; null for directories, local checkouts, and checkout-branch worktrees                                                           |
+| `isPaseoOwnedWorktree` | `boolean`                                       | Whether Paseo owns and may remove/recreate the backing `worktreeRoot`                                                                                                                 |
+| `mainRepoRoot`         | `string \| null`                                | Main repository root for worktree checkouts, independent of both exact `cwd` and backing `worktreeRoot`                                                                               |
+| `createdAt`            | `string` (ISO 8601)                             |                                                                                                                                                                                       |
+| `updatedAt`            | `string` (ISO 8601)                             |                                                                                                                                                                                       |
+| `archivedAt`           | `string \| null` (ISO 8601)                     | Soft-delete; required nullable                                                                                                                                                        |
+| `pinnedAt`             | `string \| null` (ISO 8601)                     | Pinned-to-top-of-sidebar timestamp; null means "not pinned"                                                                                                                           |

-> **Opaque-ID invariant:** `workspaceId` is opaque identity, never a filesystem path. Filesystem and git operations take `cwd`/`workspaceDirectory` only — never the id. Path-derived grouping keys (e.g. `deriveWorkspaceDirectoryKey`, used at bootstrap to group agents into a workspace) are directory keys, not workspace identity, and must not be persisted or compared as ids.
+> **Opaque-ID invariant:** `workspaceId` is opaque identity, never a filesystem path. Filesystem and git operations take `cwd`/`workspaceDirectory` only — never the id. A compatibility-only first-materialization bootstrap still groups pre-registry agent records by path and Git remote so existing installs retain their legacy records. That grouping never runs against a live registry, and its keys are not runtime project or workspace identity.

 `projectId` is still a real FK: workspace records should have a matching project record. Read-only
 history surfaces tolerate transient orphaned workspaces by omitting those rows so one bad FK cannot
@@ -64,6 +64,8 @@ The button is `<Button>` (`packages/app/src/components/ui/button.tsx`). It has f

 Sizes: `xs` for ultra-tight inline triggers. `sm` for any button sitting in a row. `md` is the page default. `lg` is reserved for large standalone CTAs.

+Sizes are a shared contract across control kinds, defined once in `control-geometry.ts`: `xs` = 28px tall with `fontSize.xs` labels, `sm` = 32px with `fontSize.sm`, `md`/`lg` = 44px with `fontSize.sm`. `<SegmentedControl>` (`packages/app/src/components/ui/segmented-control.tsx`) takes the same `xs`/`sm`/`md` sizes — a segmented control next to a `<Button>` of the same size always matches in height, label size, and horizontal padding. Thin chrome such as the file toolbar uses `xs`; settings rows use `sm`. Never shrink a control's font or padding locally to fit a context — if the context needs a smaller control, the size tier is missing or the wrong one is in use.
+
 A `<Pressable>` wrapping a `<Text>` is a sixth variant. It is wrong. `<Button>` accepts `style`, `textStyle`, `leftIcon`, `disabled`, `size`, and `variant`.

 ---
@@ -278,6 +278,15 @@ Service proxy hostnames use the double-dash shape: `web--feature-auth--project.l
 }
 ```

+Service ports use OS ephemeral allocation by default. Set `worktrees.servicePorts` in
+`$PASEO_HOME/config.json`, or replace it for one project with `worktree.servicePorts` in
+`paseo.json`. The block accepts an inclusive `range` such as `"3000-4000"` or a `portScript`
+executable. Since `portScript` is executed directly without a shell, it must point to a real executable (e.g., a binary or a script with a proper shebang like `#!/bin/sh`) rather than an inline shell command or shell pipeline. For inline shell commands or pipelines, wrap them in a small script. `portScript` runs in the workspace directory with four arguments: service name,
+workspace ID, branch name, and worktree path. A missing branch is passed as an empty string. The same
+values are available as `PASEO_SCRIPTNAME`, `PASEO_WORKSPACE_ID`, `PASEO_BRANCH_NAME`, and
+`PASEO_WORKTREE_PATH`. The script must print one valid TCP port. Paseo trusts the external allocator,
+so the port may already be bound. `portScript` takes precedence when both values are present.
+
 ## Bundled daemon web UI

 > The user-facing guide for this feature (enabling it, reverse proxy, TLS, tunnels, security) lives at [public-docs/web-ui.md](../public-docs/web-ui.md). This section is the contributor/build reference: how the artifact is produced, bundled, and excluded from desktop packaging.
@@ -374,11 +383,14 @@ install.

 Use `npm run cli` to run the in-repo CLI from source (`npx tsx packages/cli/src/index.ts`). The script wraps the CLI with `scripts/dev-home.sh`, so it automatically uses this checkout's `.dev/paseo-home` and dev daemon endpoint unless you pass an explicit override. The globally installed `paseo` binary on macOS is a symlink into the installed Paseo desktop app, not this checkout — use it to drive the desktop's built-in daemon, but use `npm run cli` when you want to talk to the CLI you are editing.

+Canonical automation uses `paseo workspace create/ls/archive`, `paseo heartbeat create/update/delete`, and the full `paseo schedule` group. MCP heartbeat automation is intentionally smaller: create and delete only. Detach remains an explicit user lifecycle action rather than an agent tool. `paseo run --new-workspace local|worktree` composes workspace creation with agent creation. The old `paseo worktree` and `paseo run --worktree` forms are hidden compatibility aliases.
+
 ```bash
 npm run cli -- ls -a -g              # List all agents globally
 npm run cli -- ls -a -g --json       # Same, as JSON
 npm run cli -- inspect <id>          # Show detailed agent info
 npm run cli -- logs <id>             # View agent timeline
+npm run cli -- agent open <id>       # Focus an existing agent in Paseo Desktop
 npm run cli -- daemon status         # Check daemon status
 npm run cli -- clone owner/repo --dir ~/workspace # Clone GitHub repo and register project
 ```
@@ -389,6 +401,11 @@ Use `--host <host:port>` to point the CLI at a different daemon:
 npm run cli -- --host localhost:7777 ls -a
 ```

+Desktop integrations can focus an existing agent without creating one or
+sending a message. Use `paseo://h/<server-id>/agent/<agent-id>`, or run
+`paseo agent open <agent-id>`. The CLI reads the local daemon's server ID by
+default; pass `--server <server-id>` when targeting another server.
+
 ## Agent state

 Agent data lives at:
@@ -73,6 +73,20 @@ only use local param fallback during cold mount (`/` or empty pathname), or a
 hidden workspace can overwrite the remembered workspace before Settings or
 History returns.

+## Agent Targets
+
+Notifications and agent URLs enter the router with different authoritative
+targets.
+
+- Notifications carry `serverId`, `workspaceId`, and `agentId`. Route them
+  directly to the workspace with the agent open intent.
+- Agent URLs carry only `serverId` and `agentId`. Route them through
+  `/h/[serverId]/agent/[agentId]`; that route waits for the named host, resolves
+  the agent's workspace from the host, and then opens the agent there.
+
+Both paths converge on `navigateToAgent()`. Do not make notification routing
+guess a workspace, and do not add a workspace to the stable agent URL format.
+
 ## Params

 Required dynamic params belong to the matched route.
@@ -57,7 +57,7 @@ Android touches sailed straight through to the chat scroll view behind it.

 Two escape hatches in the codebase:

- **`Modal`** (combobox, tooltip on native) — opens a new Android window, so
+- **`Modal`** (combobox, dropdown menu and tooltip on native) — opens a new Android window, so
  hit-testing starts fresh in that window. Side effect: a Modal opening on
  Android can detach the IME from an underlying TextInput. Fine for combobox
  (it has its own input) and tooltip (no input). **Not** fine for autocomplete
@@ -70,7 +70,13 @@ Two escape hatches in the codebase:
  overlays can use the current `FloatingPanelPortalHost` so sliding sidebars
  cover them.

-Choose Modal vs Portal by whether the underlying input can lose its keyboard.
+  Choose Modal vs Portal by whether the underlying input can lose its keyboard.
+
+On web, dropdown menus render into the shared `overlay-root`, not React Native
+Web's `<Modal>`/`<dialog>`. A browser top-layer dialog always paints above
+ordinary portals regardless of `z-index`, which would hide app toasts and
+tooltips behind the menu. The shared overlay scale keeps menus below toasts and
+lets tooltip portals paint above both.

 ## Gotcha 2 — Portal breaks lifecycle and coordinate-system inheritance

@@ -84,6 +84,20 @@ Register the adapter in `defaultForgeRegistry` with:
 - `matchesHost` from manifest `cloudHosts`
 - `probeHost` when self-hosted/Enterprise detection is supported

+Current change-request lookup uses two identities deliberately:
+
+- An open PR/MR belongs to the checkout when its head branch and head repository
+  match. Its remote head SHA may differ because the checkout can be ahead,
+  behind, or contain commits that have not been pushed yet.
+- A merged or closed PR/MR belongs to the checkout only when its recorded head
+  SHA exactly matches the checkout's current `HEAD`. Branch names are reusable;
+  selecting the newest terminal request by branch alone can silently attach an
+  old promotion or feature request to new work.
+
+Thread the checkout head SHA through adapter cache and poll identities as well
+as the lookup itself. Otherwise a commit made on the same branch can inherit the
+previous commit's cached terminal status until the cache expires.
+
 Cloud hosts in the manifest are a bounded public-host list, not a self-host
 allowlist. Self-hosted detection is a trust gate: Paseo only talks to a forge
 host that is either a known cloud host or one the CLI is already authenticated
@@ -2,22 +2,22 @@

 Authoritative terminology. UI label wins. Don't invent synonyms; use what's here.

- **Project** — Logical grouping of workspaces sharing a git remote (or main repo root). UI: "Project" / "Add project". Code: `ProjectSummary` (`packages/app/src/utils/projects.ts:22`), `projectKey` (`packages/server/src/server/workspace-registry-model.ts:16`). Forbidden: "Repo", "Repository" as UI label.
+- **Project** — A stable, exact selected-root record. New IDs are opaque `prj_<16 hex>` values; older remote-shaped and path-shaped IDs remain readable compatibility records. Git facts can update mutable kind metadata but never project identity, root, or default display name. UI: "Project" / "Add project". Forbidden: "Repo", "Repository" as UI label.
 - **Workspace** — One concrete `cwd` on one daemon, with git state; belongs to exactly one project. Its `id` is opaque workspace identity; its `cwd` is the filesystem directory. UI: "Workspace". Code: `WorkspaceDescriptorPayload` (`packages/protocol/src/messages.ts:2178`). Don't confuse with: Branch (one branch can back many workspaces via worktrees). Forbidden: "Folder", "Directory" as UI label.
- **Archive workspace** — Removes one workspace from active use and archives everything it owns. UI and app shortcuts always say "Archive workspace", regardless of backing. The daemon leaves ordinary directories intact and removes a Paseo-owned worktree only when no active workspace still references it. CLI/MCP **archive worktree** is a separate lower-level operation that archives every workspace on that worktree.
- **Workspace kind** — `"directory" | "local_checkout" | "worktree"`. The git-derived, persisted property of a workspace, used across its lifetime (archive safety, sidebar, grouping). Derived from the cwd's git reality (`deriveWorkspaceKind`, `packages/server/src/server/workspace-registry-model.ts:158`), not stored from a user choice. Code: `PersistedWorkspaceKind` (`packages/server/src/server/workspace-registry-model.ts:8`). Don't confuse with **Isolation** (the create-time intent).
+- **Archive workspace** — Removes one workspace from active use and archives everything it owns. UI, CLI, and MCP always say "Archive workspace", regardless of backing. The daemon leaves ordinary directories intact and removes a Paseo-owned worktree only when no active workspace still references it.
+- **Workspace kind** — `"directory" | "local_checkout" | "worktree"`. The git-derived, persisted property of a workspace, used across its lifetime (archive safety, sidebar, grouping). Derived from the cwd's git reality by `deriveWorkspaceKind` in `workspace-registry-model.ts`, not stored from a user choice. Don't confuse with **Isolation** (the create-time intent).
 - **Isolation** — Create-time choice for a new workspace: reuse the existing checkout (**Local**) or cut a dedicated git worktree (**New worktree**). A transient setup input, also remembered as a create-form preference; it is not a workspace property. UI: "Isolation" control on the New Workspace screen. Code: `isolation` (`"local" | "worktree"`), `useWorkspaceIsolation` (`packages/app/src/screens/new-workspace-screen.tsx`); persisted as `FormPreferences.isolation` (`packages/app/src/create-agent-preferences/preferences.ts`). Distinct from **Workspace kind**, which is the git-derived property the intent produces (Local → `local_checkout` or `directory` by git-ness; New worktree → `worktree`). On the wire it is the create request's `source.kind` (`directory | worktree`, `packages/protocol/src/messages.ts:1693`).
 - **Agent** — See **Agent session**. UI still says "Agent" / "New Agent" in places, but moving toward **Agent session** as the canonical term. Code: `AgentSnapshotPayload` (`packages/protocol/src/messages.ts:608`). Forbidden: "Task", "Job", "Run".
 - **Daemon** — Local Paseo server process; identified by `serverId`. UI: "Daemon" (system contexts only). Code: `serverId` in `ServerInfoStatusPayloadSchema` (`packages/protocol/src/messages.ts:1936`), `DaemonClient` (`packages/client/src/daemon-client.ts`).
 - **Host** — Client-side connection profile pointing at a daemon; bundles one or more `HostConnection`s. UI: "Host" / "Add host" / "Switch host". Code: `HostProfile` (`packages/app/src/types/host-connection.ts:37`). Forbidden: "Connection" (means `HostConnection`, not host).
 - **Project host entry** — One row in a project for a single (project, daemon) pair, aggregating that daemon's workspaces in the project. Internal. Code: `ProjectHostEntry` (`packages/app/src/utils/projects.ts:11`). Don't introduce "Checkout" as a synonym.
- **Placement** — One workspace's relationship to its project (projectKey, projectName, git checkout snapshot). Internal. Code: `ProjectPlacementPayload` (`packages/protocol/src/messages.ts:2113`).
+- **Placement** — One workspace's stable foreign-key relationship to its project plus its git checkout snapshot. Internal. An explicit creation `projectId` is authoritative when active.
 - **Branch** — Plain git branch. UI: "Switch branch". Code: `currentBranch` in `WorkspaceGitRuntimePayloadSchema` (`packages/protocol/src/messages.ts:2136`); `BranchSwitcher` (`packages/app/src/components/branch-switcher.tsx`).
 - **Forge** — Git hosting service behind Paseo's change-request features: GitHub, GitLab, Gitea, Forgejo, or a future registered adapter. Code: `ForgeService`, `forge-registry`, `forge-resolver`. Use `forge` for internal abstraction and registry IDs; use concrete forge names only when a behavior or RPC is forge-specific.
 - **Change request** — Forge-neutral term for a proposed branch-to-branch code change. UI normally renders the forge noun instead: GitHub/Gitea/Forgejo "PR", GitLab "MR". Code: `forge_change_request` attachments, `checkoutSource: { kind: "change_request" }`, and PR/MR status payloads.
 - **MR** — GitLab merge request. UI label for GitLab change requests only; do not use MR for GitHub/Gitea/Forgejo.
- **Worktree** — Paseo-managed git worktree (`~/.paseo/worktrees/{name}`); also a `workspaceKind` value. UI: CLI + `paseo.json` keys (`worktree.setup`, `worktree.teardown`) only. Code: `ProjectCheckoutLiteGitPaseoPayload` (`packages/protocol/src/messages.ts:2092`); CLI `paseo worktree` (`packages/cli/src/commands/worktree/index.ts:8`). Forbidden: "Checkout" as a synonym.
- **Repository / Remote** — Internal git inputs (`remoteUrl`, `mainRepoRoot`) used to derive `projectKey`. No UI label.
+- **Worktree** — Paseo-managed git worktree (`~/.paseo/worktrees/{name}`); also a `workspaceKind` value. User-facing creation treats it as the `worktree` workspace isolation choice. Code and `paseo.json` retain worktree terminology for git lifecycle implementation. Forbidden: "Checkout" as a product synonym.
+- **Repository / Remote** — Internal Git observations. They may affect mutable kind/branch metadata but never project identity, root, display name, or workspace membership. No UI label.
 - **Directory-backed surface** — A right-sidebar surface whose content is determined by the workspace's `cwd`, so two workspaces on the same directory see identical content: git diff/status, forge change-request info, file preview/explorer contents. Keyed by `(serverId, cwd)`, never `workspaceId`. See [architecture.md](architecture.md#right-sidebar-boundary-directory-backed-vs-workspace-owned).
 - **Workspace-owned state** — Per-workspace state that never leaks to a same-`cwd` sibling: tabs, agents, terminals, panes, title, plus review drafts, diff-mode overrides, composer attachments, and file-explorer open/expand state. Keyed by `workspaceId` (`cwd` only as a fallback for old payloads). See [architecture.md](architecture.md#right-sidebar-boundary-directory-backed-vs-workspace-owned).
 - **Workspace status bucket** — Aggregate activity signal for a workspace row. Same-`cwd` workspaces intentionally share agent and terminal status buckets, while tab, agent, and terminal visibility remains scoped by `workspaceId`.
@@ -29,7 +29,7 @@ Authoritative terminology. UI label wins. Don't invent synonyms; use what's here
 - **Tab** — UI surface representing one session inside a workspace. Not a conceptual unit; use **Agent session** when talking about the model. Code: `WorkspaceTabDescriptor` (`packages/app/src/screens/workspace/workspace-tabs-types.ts`).
 - **Terminal** — Workspace-scoped PTY shell streamed over the binary mux channel. UI: "Terminal". Code: `TerminalStreamFrame` (`packages/protocol/src/terminal-stream-protocol.ts`).
 - **Schedule** — Cron-style trigger that creates new agents. UI: CLI/MCP (`paseo schedule`, `create_schedule`). Don't confuse with: Heartbeat (cron prompt back into the same agent) or Loop (iterative re-execution of one agent).
- **Heartbeat** — Cron-style prompt sent back into the same agent/conversation. MCP: `create_heartbeat`. Use for reminders and babysitting where the status should return inline.
+- **Heartbeat** — Ephemeral cron prompt sent back into the same agent/conversation. Agent surfaces expose create, update cron, and delete only. Use for reminders and babysitting where status should return inline.
 - **Mode** — Provider-specific operational mode (plan, default, full-access, …). UI: icon-only. Code: `modeId` in `AgentSessionConfig` (`packages/protocol/src/messages.ts:257`).
 - **Attachment** — External or local context bound to an agent prompt: forge issue/change request, review context, uploaded file, text, or image. UI: "Attach issue or PR/MR". Code: `AgentAttachment` (`packages/protocol/src/messages.ts:782`).
 - **Composer** — The whole prompt surface for sending work to an agent. Code: `Composer` (`packages/app/src/composer/index.tsx`). Don't call this "message input" except for the text-entry subcomponent.
@@ -0,0 +1,72 @@
+# Paseo Hub relationship
+
+Paseo Hub is an explicit opt-in connection from one Paseo daemon to one Hub. Running a daemon does
+not register it with a Hub. The relationship begins only when a user runs
+`paseo hub connect <url> --token <token>` from the daemon machine.
+
+## Connection and authority
+
+The daemon enrolls over HTTP(S), then opens and maintains a direct outbound WebSocket to the Hub.
+The Hub never discovers or acquires the daemon through Paseo's relay. The relay remains an optional
+encrypted path for normal Paseo clients and has no role in Hub enrollment, authentication, dispatch,
+or reconnects.
+
+The daemon persists a relationship ID and private connection credential before enrollment. The
+relationship is independent of its current transport, so a future transport can replace the direct
+WebSocket without pairing again. The current foundation supports one Hub relationship per daemon.
+
+Normal authenticated daemon sessions may run the `hub.management.daemon.connect`,
+`hub.management.daemon.get_status`, and `hub.management.daemon.disconnect` RPCs. Hub connections
+receive only `hub.execution.*` authority, so execution credentials cannot manage the relationship.
+
+## Session grants and execution ownership
+
+Trusted clients and the Hub use the same `Session` implementation. The connection boundary supplies
+grants: trusted clients receive `*`, while an enrolled Hub connection receives its persisted
+`hub.execution.*` grant. One matcher handles exact RPC names and trailing namespace wildcards for
+both inbound requests and outbound messages. A denied request returns the ordinary `rpc_error`
+shape.
+
+The Hub connection still has a narrow lifecycle boundary: it has no trusted-client hello/resume,
+browser, binary, retained-session, or broadcast state. Its outbound execution events include only
+agents owned by that daemon identity, so unrelated local agents remain outside the Hub surface.
+
+Each Hub create carries an execution ID. The daemon stores that ID with the agent's relationship
+owner before acknowledging creation. Duplicate or replayed creates for the same daemon and
+execution resolve to the same durable agent. After a lost response, reconnect, or daemon restart,
+the Hub retries `hub.execution.agent.create.request` with the same execution ID. The idempotent
+response returns the existing agent and its current state; there is no separate reconciliation RPC.
+Transient stream frames are not durably replayed.
+
+Daemon restart preserves the Hub relationship and owned execution identity, but interrupts any
+active turn. The daemon persists that agent as `closed`; an idempotent create retry returns the same
+daemon, execution, and agent identity with that terminal state. Paseo never stores or automatically
+replays the original prompt. A duplicate create returns the existing agent without starting another
+turn.
+
+Hub creates use the same agent creation path as trusted clients. They may select any existing
+worktree target shape and may request `autoArchive`. Worktree creation and terminal auto-archive use
+the shared workspace-aware lifecycle policy; Hub does not have a second launch or cleanup path.
+
+## Disconnect and revocation
+
+Normal socket loss reconnects the active relationship with bounded exponential backoff and jitter.
+Daemon restart loads the same relationship and credential and reconnects without another enrollment
+ceremony.
+
+Hub authentication rejection or close code `4403` permanently revokes the local relationship. The
+daemon deletes its credential, stops reconnecting, and retains only the relationship ID, Hub origin,
+scopes, and a sanitized reason for status reporting.
+
+`paseo hub disconnect` disables socket reconnect before requesting remote revocation. If the Hub is
+offline, the daemon persists `disconnecting` and retries revocation across daemon restarts without
+opening a Hub socket. This also covers an enrollment whose request may have succeeded but whose
+response was lost. `--force` removes local authority immediately and warns that remote revocation may
+still be pending.
+
+## Cross-repository compatibility
+
+The consumer implementation lives in Paseo Cloud. Cloud owns its copy of the Hub wire schemas and
+has no Paseo runtime or build dependency. Cross-repository end-to-end verification separately builds
+a Paseo source checkout and exercises the real daemon, CLI, direct WebSocket, Cloud service, and
+Postgres. That compatibility fixture is not a package dependency or fallback implementation.
@@ -73,7 +73,7 @@ Anyone who builds software:
 - Built-in providers: Claude Code (Agent SDK), Codex (app-server), GitHub Copilot (ACP), OpenCode, Pi, OMP
 - One-click ACP provider catalog: CodeWhale, Cursor, Hermes, Qwen Coder, Kimi Code, and others — plus custom ACP providers
 - Voice mode: dictate prompts or talk through problems hands-free
- MCP server exposes the daemon to other agents (create_agent, send_agent_prompt, schedules, terminals, worktrees, workspace renaming)
+- MCP server exposes the daemon to other agents (workspaces, create/detach agent, schedules, heartbeats, terminals, workspace renaming)
 - Scheduled agents (cron-style triggers) via app, CLI, and MCP
 - Frequent releases (multiple per week)
 - Community contributions across packaging, providers, and bug fixes
@@ -24,7 +24,7 @@ Paseo tools are not implemented as MCP tools internally. They live in a shared t

 Pi is a process-backed provider. Paseo requires the user to have the `pi` binary installed and talks to it through `pi --mode rpc`; the server package does not embed Pi's SDK/runtime packages.

-Paseo's per-agent and daemon-wide system prompts are passed to Pi with `--append-system-prompt`, so Pi keeps its default coding prompt while receiving Paseo's additional instructions.
+Paseo's per-agent and daemon-wide system prompts are appended by its generated Pi integration extension. Paseo deliberately does not pass `--append-system-prompt`, because that flag replaces Pi's automatic `APPEND_SYSTEM.md` discovery instead of composing with it.

 Pi model records expose input capabilities through `model.input`. Only send raw RPC `images` when the current model explicitly includes `"image"` in that list. Text-only Pi/OMP models reject image content and persist the rejected image in JSONL history, so image prompts for those models must be materialized to a local file and passed as a text path hint instead.

@@ -44,6 +44,8 @@ OpenCode owns user message IDs. Do not pass Paseo-generated IDs to OpenCode prom

 Every provider adapter owns its canonical user-message timeline rows. When a foreground prompt is accepted, the adapter must emit exactly one `user_message` timeline item for that submitted prompt, using the same message ID it gives to or receives from the provider runtime. Optimistic client messages are UI-only and provider transcript echoes are optional; neither is allowed to be the only source of truth. If the provider later echoes the same submitted user message, dedupe it only within the active turn. Prefer provider-visible message IDs, but ACP runtimes may omit that ID or replace it with a provider-owned one; in that case suppress only echo chunks whose accumulated text is a prefix of the active submitted prompt. Do not perform global transcript text dedupe.

+Submitted user-message rows preserve both identities: `messageId` is the provider-visible ID and the optional `clientMessageId` is the Paseo ID from `AgentRunOptions`. Attach `clientMessageId` only to the canonical row for that foreground submission; provider history and externally initiated user rows do not have a Paseo client ID.
+
 Draft metadata lookups should avoid creating provider sessions when the upstream provider has top-level APIs for that metadata. Prefer `AgentClient.fetchCatalog`, `listCommands`, or `listFeatures` over creating a scratch `AgentSession`; scratch sessions can show up as empty native sessions in provider import/history UIs. `fetchCatalog` is the single discovery API for models and modes — provider implementations may use one process, separate upstream calls, or static data internally, but callers outside the provider do not get separate runtime model/mode probes. Draft feature and command listing must use the explicit draft model only; if no model is selected yet, return no metadata instead of resolving a default model through catalog discovery.

 Provider session import has its own contract. The picker calls `listImportableSessions` and receives rows only: provider handle, cwd, title, prompt previews, and last activity. Import calls `importSession({ providerHandleId, cwd })` for the selected row and must not call listing again. The provider returns the resumed session, storage config, persistence handle, and hydrated timeline for that one native session; `AgentManager.importProviderSession` seeds the daemon timeline and publishes the Paseo agent only after it is ready.
@@ -107,6 +107,6 @@ Codex also receives the Windows equivalent:
 if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" hooks codex <event>) else (paseo hooks codex <event>))
 ```

-Paseo injects `PASEO_HOOK_CLI` so Codex's hook shell cannot pick up a stale global `paseo` before the current one. The command still falls back to bare `paseo` if the env is missing, and it still no-ops outside Paseo terminals because the `PASEO_TERMINAL_ID` gate remains first. Paseo also prepends the CLI binary directory to each terminal `PATH` as a secondary fallback. All other behavior lives in `paseo hooks`: read the env, map the event, POST activity, and no-op/fail-open when anything is missing or unavailable.
+The daemon resolves the current CLI through `PASEO_CLI` when its launcher supplies one, or through the npm package shim for standalone installs. Terminal setup exposes that resolved executable to hooks as `PASEO_HOOK_CLI`; desktop and other daemon launchers do not know about the hook-specific variable. The generated command falls back to bare `paseo` if the hook env is missing and no-ops outside Paseo terminals because the `PASEO_TERMINAL_ID` gate remains first. Paseo also prepends the resolved CLI directory to each terminal `PATH` as a secondary fallback. All other behavior lives in `paseo hooks`: read the env, map the event, POST activity, and no-op/fail-open when anything is missing or unavailable.

 If config installation fails, daemon startup and terminal spawn continue without terminal activity hooks.
@@ -177,6 +177,7 @@ Test suites in this repo are heavy. Running them in bulk freezes the machine, es
 - Never run the full Playwright E2E suite locally — defer whole-suite verification to CI. Targeted Playwright specs are allowed when you changed or need to prove that specific flow.
 - App Playwright specs share one isolated daemon per run. Helpers that create projects or workspaces must remove the daemon project record during cleanup, not only delete the temp directory. Agent helpers must pass the intended `workspaceId` through to agent creation; never infer ownership from `cwd`.
 - CI can shard app Playwright across multiple jobs; each shard still owns a full isolated daemon/relay/Metro stack from global setup. Helpers that restart the daemon must preserve the global setup environment, including disabled speech/local-model settings, so a restart does not change the tested surface or start background downloads.
+- Global setup starts Metro before Wrangler, assigns Wrangler explicit distinct relay and inspector ports, and accepts Metro as ready only when `/status` returns `packager-status:running`. A generic TCP listener is not sufficient readiness evidence.

 ## Agent authentication in tests

@@ -51,9 +51,55 @@ When a client resumes with a known cursor, it catches up after that cursor to co

 When a client resumes without a cursor, it fetches the latest tail page.

+## Client replica lifetime
+
+The host runtime owns each session replica for as long as the host remains registered. React
+providers attach message handlers and UI integrations to that replica, but mounting or unmounting a
+provider must not create or clear it. A provider can remount during Fast Refresh or ordinary UI
+recomposition while the runtime still owns the same directory snapshot and timeline cursors.
+
+Removing the host from the registry is the destructive boundary: it stops the runtime and clears the
+session and host-scoped setup state together.
+
+## Selective and legacy delivery
+
+The app chooses one delivery policy from `server_info.features.selectiveAgentTimeline`:
+
+- Selective daemons receive the union of agents visible in every pane. Additions subscribe and
+  catch up immediately. Every visibility-driven removal, including app backgrounding, stays
+  subscribed for a 30-second grace period so brief tab, pane, route, and app switches do not repeatedly
+  unsubscribe and catch up. Losing window keyboard focus does not make a selected pane invisible.
+  Disconnecting and disposal clear pending grace because the subscription itself no longer exists.
+  After grace has expired, revisiting a retained timeline displays its cached state immediately and
+  authoritative catch-up advances it to the current tail.
+- Legacy daemons keep globally streaming agent timelines. Visibility still triggers the existing
+  authoritative catch-up, but the app does not issue selective-subscription RPCs.
+
+This policy is owned by `viewed-timeline-sync.ts`; downstream reducers do not branch on daemon
+version.
+
+## Projected pages reconcile with live presentation
+
+A projected page is canonical state, not a sequence of live deltas. One projected item can overlap
+rows already received live—for example, a tool call retained at its original display position while
+its completion advances `seqEnd`, followed by a merged assistant message. The app uses
+`sourceSeqRanges` to replace overlapping assistant and reasoning projections before applying the
+remaining page through the existing stream reducer. It must not append full projected text to a
+live prefix.
+
+Optimistic user prompts occupy stable timeline slots. Catch-up never extracts, delays, or reinserts
+them. A canonical user row replaces its matching slot in place; an unmatched prompt stays exactly
+where the user submitted it. Other canonical rows are applied after the already-present timeline
+instead of relocating visible user messages around newly fetched history.
+
+Canonical submitted user rows carry the provider's `messageId` and Paseo's optional
+`clientMessageId`. Clients reconcile optimistic prompts by `clientMessageId`. Content matching is
+limited to the dated compatibility path for daemon timelines created before that field existed.
+
 ## Relevant code

 - Server live stream forwarding: `packages/server/src/server/session.ts`
 - App sync planning: `packages/app/src/timeline/timeline-sync-plan.ts`
+- App viewed-agent synchronization: `packages/app/src/timeline/viewed-timeline-sync.ts`
 - App stream/timeline reducer: `packages/app/src/timeline/session-stream-reducers.ts`
 - Session wiring: `packages/app/src/contexts/session-context.tsx`
@@ -58,6 +58,30 @@ For standard React Native components, the [Unistyles Babel plugin](https://www.u

 The important detail: the automatic native path tracks `props.style`. It does not generally track every prop that happens to carry style-like values.

+### Do Not Materialize Styles At Module Scope
+
+Never read a Unistyles style property into a module-level constant. This includes cached arrays:
+
+```tsx
+// Wrong: evaluated while the app may still be using the temporary system theme.
+const ROW_STYLE = [settingsStyles.row, settingsStyles.rowBorder];
+
+// Right: each style proxy is read when this view renders.
+<View style={[settingsStyles.row, settingsStyles.rowBorder]} />;
+```
+
+Paseo starts with adaptive themes, then applies the persisted theme after async settings load. A
+module-level read can therefore materialize the light style before a persisted dark theme is
+active. If the view mounts after that theme change, React Native receives the stale light object;
+Unistyles registers the node for future changes but does not retroactively replace its initial
+props. Settings dividers once rendered light `#e4e4e7` inside a dark `#252B2A` card for exactly
+this reason.
+
+Render-time array syntax is intentional and exempt from the app's JSX array-allocation lint rule.
+Keep the entries separate so each retains its Unistyles metadata. If composition is needed outside
+JSX, create the array inside the component or in a `useMemo` that first runs when the component
+mounts—never at module evaluation time.
+
 [`useUnistyles()`](https://www.unistyl.es/v3/references/use-unistyles) is different. It gives React access to the current theme/runtime and can make a component re-render when those values change. Use it for values that must be rendered through React props, such as icon colors or small escape hatches. Do not expect direct reads from `UnistylesRuntime` to re-render a component; [issue #817](https://github.com/jpudysz/react-native-unistyles/issues/817) is a useful reminder of that invariant.

 ## Dynamic Pixel Styles On Web
@@ -1 +1 @@
-sha256-DL1LamUyFzJOkPYR7eeIefGhzP/mcWGO5oxld/Bt8n0=
+sha256-x6jiaw7zkCuBRlddLHD0tXQxolXwr7tzIQBfWu5xnUU=
@@ -5,6 +5,7 @@
  nodejs_22,
  python3,
  makeWrapper,
+  autoPatchelfHook,
  # node-pty needs libuv headers on Linux
  libuv,
  # Exposed so downstream flakes that follow a different nixpkgs revision
@@ -59,10 +60,13 @@ buildNpmPackage rec {
  nativeBuildInputs = [
    python3 # for node-gyp (node-pty compilation)
    makeWrapper
+  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
+    autoPatchelfHook
  ];

  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
    libuv
+    stdenv.cc.cc.lib # libstdc++ for sherpa-onnx prebuilt binaries
  ];

  # Don't use the default npm build hook — we need a custom build sequence
@@ -71,10 +75,9 @@ buildNpmPackage rec {
  buildPhase = ''
    runHook preBuild

-    # Rebuild only node-pty (native addon for terminal emulation).
-    # Speech-related native modules (sherpa-onnx, onnxruntime-node) are
-    # intentionally left unbuilt — they're lazily loaded and gracefully
-    # degrade when unavailable.
+    # Rebuild only node-pty (native addon for terminal emulation). The sherpa
+    # speech runtime ships prebuilt platform packages and is copied into the
+    # daemon closure by scripts/trace-daemon.mjs.
    npm rebuild node-pty

    # Build all server packages in dependency order (defined in package.json)
@@ -89,7 +92,7 @@ buildNpmPackage rec {

    # 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
+    # forked terminal/speech worker processes) 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.
@@ -1,12 +1,12 @@
 {
  "name": "paseo",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.3",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "paseo",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "hasInstallScript": true,
      "license": "AGPL-3.0-or-later",
      "workspaces": [
@@ -2531,10 +2531,35 @@
      "optional": true,
      "peer": true
    },
+    "node_modules/@codemirror/autocomplete": {
+      "version": "6.20.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.3.tgz",
+      "integrity": "sha512-tlosUqb+3BbxCxZdu4tKeRghPFC+QM7q4X5YhKV2eCmPG+1r2F3f4AaSz5sCrFqUtX4Jh20VFTKecl16MgiV9g==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/commands": {
+      "version": "6.10.4",
+      "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.10.4.tgz",
+      "integrity": "sha512-Ryk9y9T0FFVF0cUGhAknveAyUOl/A1qReTFi+qPKtOh2Z9F4AUBz3XOrYD4ZEgZirdugVzHvd/2/Wcwy5OliTg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.7.0",
+        "@codemirror/view": "^6.27.0",
+        "@lezer/common": "^1.1.0"
+      }
+    },
    "node_modules/@codemirror/language": {
-      "version": "6.12.3",
-      "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.3.tgz",
-      "integrity": "sha512-QwCZW6Tt1siP37Jet9Tb02Zs81TQt6qQrZR2H+eGMcFsL1zMrk2/b9CLC7/9ieP1fjIUMgviLWMmgiHoJrj+ZA==",
+      "version": "6.12.4",
+      "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.4.tgz",
+      "integrity": "sha512-1q4PaT+o6PbgpkJt4Q8Fv5XJxTy4FUZ4MWETtyiDw3J0Pyr9E2vqcKL+k9wcvjNTIsauxvE7OfmWj3FRPHQ76A==",
      "license": "MIT",
      "dependencies": {
        "@codemirror/state": "^6.0.0",
@@ -2554,22 +2579,33 @@
        "@codemirror/language": "^6.0.0"
      }
    },
+    "node_modules/@codemirror/search": {
+      "version": "6.7.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.7.1.tgz",
+      "integrity": "sha512-uMe5UO6PamJtSHrXhhHOzSX3ReWtiJrva6GnPMwSOrZtiExb5X5eExhr2OUZQVvdxPsKpY3Ro2mFbQadpPWmHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.37.0",
+        "crelt": "^1.0.5"
+      }
+    },
    "node_modules/@codemirror/state": {
-      "version": "6.6.0",
-      "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.6.0.tgz",
-      "integrity": "sha512-4nbvra5R5EtiCzr9BTHiTLc+MLXK2QGiAVYMyi8PkQd3SR+6ixar/Q/01Fa21TBIDOZXgeWV4WppsQolSreAPQ==",
+      "version": "6.7.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.7.1.tgz",
+      "integrity": "sha512-9QzNDgE4EYDnAHfrTlR2lwiPciiOymLtwKK+8yHQzCc7GXhAP9xdEbEJFy2IWB1j9UGUl9BsgMmTo/ImA02T7A==",
      "license": "MIT",
      "dependencies": {
        "@marijn/find-cluster-break": "^1.0.0"
      }
    },
    "node_modules/@codemirror/view": {
-      "version": "6.43.0",
-      "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.43.0.tgz",
-      "integrity": "sha512-V7ZCLQO3Jus9hzh2jVCCPW3mO4IBMr43O37PqSUYautJSnnJF41YlgLw21x0fLJTYvJ+Vkm6Gp+qKGH9pltgXA==",
+      "version": "6.43.6",
+      "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.43.6.tgz",
+      "integrity": "sha512-EVunGSYN1wz1p75WY1s3Xg7t3i8Yol0kGZGizNdX9BUFgMFILYVe8/u6EVpo7Ff5PwbZuILb4QAq7IZoKzIEQA==",
      "license": "MIT",
      "dependencies": {
-        "@codemirror/state": "^6.6.0",
+        "@codemirror/state": "^6.7.0",
        "crelt": "^1.0.6",
        "style-mod": "^4.1.0",
        "w3c-keyname": "^2.2.4"
@@ -11055,6 +11091,19 @@
        "@lezer/lr": "^1.0.0"
      }
    },
+    "node_modules/@replit/codemirror-vim": {
+      "version": "6.3.0",
+      "resolved": "https://registry.npmjs.org/@replit/codemirror-vim/-/codemirror-vim-6.3.0.tgz",
+      "integrity": "sha512-aTx931ULAMuJx6xLf7KQDOL7CxD+Sa05FktTDrtLaSy53uj01ll3Zf17JdKsriER248oS55GBzg0CfCTjEneAQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "@codemirror/commands": "6.x.x",
+        "@codemirror/language": "6.x.x",
+        "@codemirror/search": "6.x.x",
+        "@codemirror/state": "6.x.x",
+        "@codemirror/view": "6.x.x"
+      }
+    },
    "node_modules/@rollup/pluginutils": {
      "version": "5.3.0",
      "resolved": "https://registry.npmjs.org/@rollup/pluginutils/-/pluginutils-5.3.0.tgz",
@@ -35162,8 +35211,13 @@
    },
    "packages/app": {
      "name": "@getpaseo/app",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
+        "@codemirror/commands": "6.10.4",
+        "@codemirror/language": "6.12.4",
+        "@codemirror/search": "6.7.1",
+        "@codemirror/state": "6.7.1",
+        "@codemirror/view": "6.43.6",
        "@dnd-kit/core": "^6.3.1",
        "@dnd-kit/sortable": "^10.0.0",
        "@dnd-kit/utilities": "^3.2.2",
@@ -35178,6 +35232,7 @@
        "@react-native-masked-view/masked-view": "^0.3.2",
        "@react-native/normalize-colors": "^0.81.5",
        "@react-navigation/native": "^7.1.8",
+        "@replit/codemirror-vim": "6.3.0",
        "@tanstack/react-query": "^5.90.11",
        "@tanstack/react-virtual": "^3.13.21",
        "@xterm/addon-clipboard": "^0.3.0-beta.213",
@@ -36181,12 +36236,12 @@
    },
    "packages/cli": {
      "name": "@getpaseo/cli",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
        "@clack/prompts": "^1.0.0",
-        "@getpaseo/client": "0.2.0-beta.1",
-        "@getpaseo/protocol": "0.2.0-beta.1",
-        "@getpaseo/server": "0.2.0-beta.1",
+        "@getpaseo/client": "0.2.0-beta.3",
+        "@getpaseo/protocol": "0.2.0-beta.3",
+        "@getpaseo/server": "0.2.0-beta.3",
        "chalk": "^5.3.0",
        "commander": "^12.0.0",
        "mime-types": "^2.1.35",
@@ -36432,10 +36487,10 @@
    },
    "packages/client": {
      "name": "@getpaseo/client",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
-        "@getpaseo/protocol": "0.2.0-beta.1",
-        "@getpaseo/relay": "0.2.0-beta.1",
+        "@getpaseo/protocol": "0.2.0-beta.3",
+        "@getpaseo/relay": "0.2.0-beta.3",
        "zod": "^4.4.3"
      },
      "devDependencies": {
@@ -36446,7 +36501,7 @@
    },
    "packages/desktop": {
      "name": "@getpaseo/desktop",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "license": "AGPL-3.0-or-later",
      "dependencies": {
        "@getpaseo/cli": "*",
@@ -36689,7 +36744,7 @@
    },
    "packages/expo-two-way-audio": {
      "name": "@getpaseo/expo-two-way-audio",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "license": "MIT",
      "devDependencies": {
        "@types/jest": "^29.5.14",
@@ -37585,9 +37640,9 @@
    },
    "packages/highlight": {
      "name": "@getpaseo/highlight",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
-        "@codemirror/language": "^6.12.3",
+        "@codemirror/language": "6.12.4",
        "@codemirror/legacy-modes": "^6.5.3",
        "@lezer/common": "^1.5.0",
        "@lezer/cpp": "^1.1.5",
@@ -37817,7 +37872,7 @@
    },
    "packages/protocol": {
      "name": "@getpaseo/protocol",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
        "zod": "^4.4.3"
      },
@@ -37830,7 +37885,7 @@
    },
    "packages/relay": {
      "name": "@getpaseo/relay",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
        "base64-js": "^1.5.1",
        "tweetnacl": "^1.0.3",
@@ -38048,15 +38103,15 @@
    },
    "packages/server": {
      "name": "@getpaseo/server",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
        "@agentclientprotocol/sdk": "^0.17.1",
-        "@anthropic-ai/claude-agent-sdk": "^0.3.195",
+        "@anthropic-ai/claude-agent-sdk": "^0.3.214",
        "@anthropic-ai/sdk": "^0.104.2",
-        "@getpaseo/client": "0.2.0-beta.1",
-        "@getpaseo/highlight": "0.2.0-beta.1",
-        "@getpaseo/protocol": "0.2.0-beta.1",
-        "@getpaseo/relay": "0.2.0-beta.1",
+        "@getpaseo/client": "0.2.0-beta.3",
+        "@getpaseo/highlight": "0.2.0-beta.3",
+        "@getpaseo/protocol": "0.2.0-beta.3",
+        "@getpaseo/relay": "0.2.0-beta.3",
        "@isaacs/ttlcache": "^2.1.4",
        "@modelcontextprotocol/sdk": "^1.20.1",
        "@opencode-ai/sdk": "1.14.46",
@@ -38100,22 +38155,22 @@
      }
    },
    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk/-/claude-agent-sdk-0.3.195.tgz",
-      "integrity": "sha512-FVmXu9pvOMbuBKWrF8YsYQdQ/upOpv5rS8lFAnFO5jbyXT/2hN7kEPd2vd2GJpaMvNcO/KptyQUK5AxjjTz3+w==",
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk/-/claude-agent-sdk-0.3.214.tgz",
+      "integrity": "sha512-wt5ImwhU+p259Zt4K/Q9v5xVi6ruxYO5+KFICyJxnjs/QFEClAeSRqhcXx1J8jgGfatPW1faw09hkm66680UjA==",
      "license": "SEE LICENSE IN README.md",
      "engines": {
        "node": ">=18.0.0"
      },
      "optionalDependencies": {
-        "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-linux-x64": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.3.195",
-        "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.195"
+        "@anthropic-ai/claude-agent-sdk-darwin-arm64": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-darwin-x64": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-linux-arm64": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-linux-arm64-musl": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-linux-x64": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-linux-x64-musl": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-win32-arm64": "0.3.214",
+        "@anthropic-ai/claude-agent-sdk-win32-x64": "0.3.214"
      },
      "peerDependencies": {
        "@anthropic-ai/sdk": ">=0.93.0",
@@ -38123,10 +38178,10 @@
        "zod": "^4.0.0"
      }
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-darwin-arm64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-arm64/-/claude-agent-sdk-darwin-arm64-0.3.195.tgz",
-      "integrity": "sha512-WIMM/8HRCLsTDHFTIwQvvE8WCA/oaMJtdQxsP7iNyfzIGwXbuOyU95V8vYIhZfaO2yaSpbBRncunq4CtR5H4ng==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-darwin-arm64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-arm64/-/claude-agent-sdk-darwin-arm64-0.3.214.tgz",
+      "integrity": "sha512-vAAOeVtlXs3p7MpFVfvfu9ja32eaKtB+MDZnPxCbdzxJk5nofCHlNsHa1UJwXHOsP9lOnFYNIccYztsZ4DNaJA==",
      "cpu": [
        "arm64"
      ],
@@ -38136,10 +38191,10 @@
        "darwin"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-darwin-x64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-x64/-/claude-agent-sdk-darwin-x64-0.3.195.tgz",
-      "integrity": "sha512-RY7DB+4LXosE0MJ+XELmakfPrDN1YX4lkk9CTDm28jGCVcESRz9kAEqbyaiC48dZcmN9V1NCLutzINGdcr1TBg==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-darwin-x64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-darwin-x64/-/claude-agent-sdk-darwin-x64-0.3.214.tgz",
+      "integrity": "sha512-NTbV8U2yucxCWqEiDC7L0MUehNmd8x3Op8OGzLZRhMF3xmQBy2DxpXiNZgSwwKWNDC3HdgKmJM5ZBbT7XrF/0g==",
      "cpu": [
        "x64"
      ],
@@ -38149,10 +38204,10 @@
        "darwin"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64/-/claude-agent-sdk-linux-arm64-0.3.195.tgz",
-      "integrity": "sha512-JuIq5Fnz/F1snl0aqi1gcuRZqPWoPNrL9dJ0DuievCxKkO8hnEz/Mmn5Zos7x1X8HE//ZnEvmQXoEQEZXonJew==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64/-/claude-agent-sdk-linux-arm64-0.3.214.tgz",
+      "integrity": "sha512-KBCf+BlusG0ZcgvpjjHwv1kh+6WiR8vJbPjpR2udwkrtcQgKLN+24l+FeaQEzO2TL+ExCmM1KC4tNPvnPpy+tw==",
      "cpu": [
        "arm64"
      ],
@@ -38162,10 +38217,10 @@
        "linux"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64-musl": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64-musl/-/claude-agent-sdk-linux-arm64-musl-0.3.195.tgz",
-      "integrity": "sha512-ZmyBA/AFzhgutcxb7dbhCm6GTjJytwNYXTxJoKE2B3A409WCYccjMqeji6vCMNxyyfylglGo5D8dVMIxW9aoug==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-linux-arm64-musl": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-arm64-musl/-/claude-agent-sdk-linux-arm64-musl-0.3.214.tgz",
+      "integrity": "sha512-i06wQRsmevE7spY1ryYfs+NP+xdZ1FwAyTjDaF0k/xG+cgtzZYghTFUemdYF3GVwgWgpcava9GiCFDT3DoHI6w==",
      "cpu": [
        "arm64"
      ],
@@ -38175,10 +38230,10 @@
        "linux"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-linux-x64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64/-/claude-agent-sdk-linux-x64-0.3.195.tgz",
-      "integrity": "sha512-s1lNi1cL93luoqsItH+fNO4KpIhdkvnVhWGGQUQ/8ftwa2gfmcIQnOg1hG8Ks+KzeD3UUQ8L9YEVHVADnFI/9A==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-linux-x64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64/-/claude-agent-sdk-linux-x64-0.3.214.tgz",
+      "integrity": "sha512-vqadSceJkBKHaTUszxI35uTuECGWtsHWK/mOwIJ4b9DUtYYySz6EJEk4gHg4ccutisJ/oRVCpFXHIKFb+osrKw==",
      "cpu": [
        "x64"
      ],
@@ -38188,10 +38243,10 @@
        "linux"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-linux-x64-musl": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64-musl/-/claude-agent-sdk-linux-x64-musl-0.3.195.tgz",
-      "integrity": "sha512-nf8Q/LauB+ZOC6QDjxNhbsvwUtYjKYnaWJLTYFwhkmsLujePnety1AtT/1ubaUoq5AM1j297DhMlYTasa79OUA==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-linux-x64-musl": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-linux-x64-musl/-/claude-agent-sdk-linux-x64-musl-0.3.214.tgz",
+      "integrity": "sha512-948RstHDhs0E69h+2dKYWIAL1kcwEme4zvtgNUwP8XpKXzWOhrTKmd6MAokHn25zwfuSx5d+HE0XHfFH6R4hLg==",
      "cpu": [
        "x64"
      ],
@@ -38201,10 +38256,10 @@
        "linux"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-win32-arm64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-arm64/-/claude-agent-sdk-win32-arm64-0.3.195.tgz",
-      "integrity": "sha512-hbkDE+xPIZzRWm+D+BKrH9uJH6USIZdDIlsyrIlGi3JFHoieYoA1vdUNyldSS9+F3ZqQtfPjr2Qy08IVB6akYA==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-win32-arm64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-arm64/-/claude-agent-sdk-win32-arm64-0.3.214.tgz",
+      "integrity": "sha512-CEKlPFCPv+ee79utQMEDSsgeo2f27ulhNHpjrKIt1jXz5G04J7lAWN/QwvPDv9XaLBkWpyfqZWiPXlRcwuaO/w==",
      "cpu": [
        "arm64"
      ],
@@ -38214,10 +38269,10 @@
        "win32"
      ]
    },
-    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk-win32-x64": {
-      "version": "0.3.195",
-      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-x64/-/claude-agent-sdk-win32-x64-0.3.195.tgz",
-      "integrity": "sha512-av0piEB3X1Dzhpr8A+DqHVZ9y8s1jpn8enzwX0TKKUPBn5IqLTWC7wD6v66aoUgu4f+g4ThZirmDZA6shyPEZQ==",
+    "packages/server/node_modules/@anthropic-ai/claude-agent-sdk/node_modules/@anthropic-ai/claude-agent-sdk-win32-x64": {
+      "version": "0.3.214",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/claude-agent-sdk-win32-x64/-/claude-agent-sdk-win32-x64-0.3.214.tgz",
+      "integrity": "sha512-cJMJfFoR9IWBZWnTtt9PnEm89hGOsZjoDNjOCEOF3+x+g/ANIXAjMJTcaQYv2HKh6MylWZ0AkxBASI+twkukaQ==",
      "cpu": [
        "x64"
      ],
@@ -38593,7 +38648,7 @@
    },
    "packages/website": {
      "name": "@getpaseo/website",
-      "version": "0.2.0-beta.1",
+      "version": "0.2.0-beta.3",
      "dependencies": {
        "@cloudflare/vite-plugin": "^1.29.1",
        "@cloudflare/workers-types": "^4.20260317.1",
@@ -1,6 +1,6 @@
 {
  "name": "paseo",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.3",
  "private": true,
  "description": "Paseo: voice-controlled development environment for local AI coding agents",
  "keywords": [
@@ -132,6 +132,8 @@
    "ws": "^8.20.0"
  },
  "overrides": {
+    "@codemirror/language": "6.12.4",
+    "@codemirror/view": "6.43.6",
    "lightningcss": "1.30.1",
    "react": "19.1.0",
    "react-dom": "19.1.0",
@@ -0,0 +1,49 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { test, expect, type Page } from "./fixtures";
+import { seedMockAgentWorkspace, openAgentRoute } from "./helpers/mock-agent";
+
+function visibleComposer(page: Page) {
+  return page.locator("textarea[data-composer-input]").filter({ visible: true }).first();
+}
+
+test("adds a changed file to the focused chat without replacing its composer draft", async ({
+  page,
+}) => {
+  const workspace = await seedMockAgentWorkspace({
+    repoPrefix: "add-file-to-chat-",
+    title: "Target chat",
+  });
+  const relativePath = "src/changed file.ts";
+
+  try {
+    await mkdir(path.join(workspace.cwd, "src"), { recursive: true });
+    await writeFile(path.join(workspace.cwd, relativePath), "export const changed = true;\n");
+    await workspace.client.checkoutRefresh(workspace.cwd);
+
+    await page.setViewportSize({ width: 1400, height: 900 });
+    await openAgentRoute(page, {
+      workspaceId: workspace.workspaceId,
+      agentId: workspace.agentId,
+    });
+
+    const agentComposer = visibleComposer(page);
+    await expect(agentComposer).toBeEditable({ timeout: 30_000 });
+    await agentComposer.fill("Preserve this thought");
+
+    await page.getByRole("button", { name: "Open explorer" }).click();
+    await page.getByTestId("explorer-tab-changes").click();
+    const changedFile = page.getByText("changed file.ts", { exact: true }).first();
+    await expect(changedFile).toBeVisible({ timeout: 30_000 });
+    await page.getByTestId("diff-file-0-toggle").click({ button: "right" });
+    await page.getByTestId("diff-file-0-add-to-chat").click();
+
+    const attachment = page.getByTestId("composer-workspace-file-attachment-pill");
+    await expect(attachment).toContainText("changed file.ts");
+    await expect(attachment).toContainText(relativePath);
+    await expect(agentComposer).toHaveValue("Preserve this thought");
+    await expect(agentComposer).toBeFocused();
+  } finally {
+    await workspace.cleanup();
+  }
+});
@@ -0,0 +1,115 @@
+import { mkdtempSync, realpathSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { test, expect } from "./fixtures";
+import { openSessions } from "./helpers/archive-tab";
+import {
+  assertChatTranscript,
+  cleanupRewindFlow,
+  launchAgent,
+  sendMessage,
+  type AgentHandle,
+} from "./helpers/rewind-flow";
+import type { SeedDaemonClient } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { waitForSidebarHydration } from "./helpers/workspace-ui";
+
+interface TimelineClient extends SeedDaemonClient {
+  fetchAgentTimeline(
+    agentId: string,
+    options: { direction: "tail"; projection: "projected"; limit: number },
+  ): Promise<unknown>;
+}
+
+const INITIAL_PROMPT = "Reply with exactly CODEX_ARCHIVE_TIMELINE_SENTINEL and nothing else.";
+const INITIAL_REPLY = "CODEX_ARCHIVE_TIMELINE_SENTINEL";
+const FOLLOW_UP_PROMPT = "Reply with exactly CODEX_UNARCHIVED_SENTINEL and nothing else.";
+const FOLLOW_UP_REPLY = "CODEX_UNARCHIVED_SENTINEL";
+
+async function historyContainsAgent(client: SeedDaemonClient, agentId: string): Promise<boolean> {
+  const history = await client.fetchAgentHistory({ page: { limit: 200 } });
+  return history.entries.some((entry) => entry.agent.id === agentId);
+}
+
+test.describe("archived Codex agent recovery", () => {
+  test.setTimeout(600_000);
+
+  test("cold-opens without provider history, then unarchives and restores the conversation", async ({
+    page,
+  }) => {
+    const cwd = realpathSync(mkdtempSync(path.join(tmpdir(), "paseo-archived-codex-")));
+    let handle: AgentHandle | undefined;
+
+    try {
+      handle = await launchAgent({
+        page,
+        provider: "codex",
+        cwd,
+        mode: "full-access",
+      });
+      await sendMessage(handle, INITIAL_PROMPT);
+      await assertChatTranscript(handle, [
+        { role: "user", text: INITIAL_PROMPT },
+        { role: "assistant", text: INITIAL_REPLY },
+      ]);
+
+      await handle.client.archiveAgent(handle.agentId);
+      await expect
+        .poll(
+          async () =>
+            (await handle?.client.fetchAgent({ agentId: handle.agentId }))?.agent.archivedAt ??
+            null,
+          { timeout: 30_000 },
+        )
+        .not.toBeNull();
+
+      const timelineClient = handle.client as TimelineClient;
+      await expect(
+        timelineClient.fetchAgentTimeline(handle.agentId, {
+          direction: "tail",
+          projection: "projected",
+          limit: 100,
+        }),
+      ).rejects.toThrow(/archiv/i);
+      await expect
+        .poll(async () => (handle ? historyContainsAgent(handle.client, handle.agentId) : false), {
+          timeout: 30_000,
+        })
+        .toBe(true);
+
+      await page.reload();
+      await waitForSidebarHydration(page);
+      await openSessions(page);
+      await page.getByTestId(`agent-row-${getServerId()}-${handle.agentId}`).click();
+
+      await expect(
+        page.getByTestId(`workspace-tab-agent_${handle.agentId}`).filter({ visible: true }).first(),
+      ).toBeVisible({ timeout: 30_000 });
+      await expect(page.getByText("This agent is archived", { exact: true })).toBeVisible({
+        timeout: 30_000,
+      });
+      await expect(page.getByTestId("agent-load-error")).toHaveCount(0);
+      await expect(page.getByTestId("agent-timeline-sync-error")).toHaveCount(0);
+      await expect(page.getByTestId("user-message")).toHaveCount(0);
+
+      await page.getByRole("button", { name: "Unarchive" }).click();
+      await expect(page.getByRole("button", { name: "Unarchive" })).toHaveCount(0, {
+        timeout: 60_000,
+      });
+      await assertChatTranscript(handle, [
+        { role: "user", text: INITIAL_PROMPT },
+        { role: "assistant", text: INITIAL_REPLY },
+      ]);
+
+      await sendMessage(handle, FOLLOW_UP_PROMPT);
+      await assertChatTranscript(handle, [
+        { role: "user", text: INITIAL_PROMPT },
+        { role: "assistant", text: INITIAL_REPLY },
+        { role: "user", text: FOLLOW_UP_PROMPT },
+        { role: "assistant", text: FOLLOW_UP_REPLY },
+      ]);
+    } finally {
+      await cleanupRewindFlow({ handle, cwd });
+    }
+  });
+});
@@ -28,26 +28,20 @@ test("commit history shows dates and shares diff layout preferences", async ({

  const panel = page.getByTestId("commit-diff-panel").filter({ visible: true });
  await expect(panel.getByTestId("commit-diff-toolbar")).toBeVisible({ timeout: 30_000 });
-  await expect(panel.getByTestId("commit-diff-layout-unified")).toHaveAttribute(
-    "aria-selected",
-    "true",
-  );
+  const layoutToggle = panel.getByTestId("commit-diff-toggle-layout");
+  await expect(layoutToggle).toHaveAccessibleName("Switch to side-by-side diff");
  await expect(panel.getByTestId("diff-code-row-0")).toBeVisible({ timeout: 30_000 });

-  await panel.getByTestId("commit-diff-layout-split").click();
-  await expect(panel.getByTestId("commit-diff-layout-split")).toHaveAttribute(
-    "aria-selected",
-    "true",
-  );
+  await layoutToggle.click();
+  await expect(layoutToggle).toHaveAccessibleName("Switch to unified diff");
  await expect(panel.getByTestId("diff-code-row-0")).toHaveCount(0);
  await expect(panel.getByTestId("diff-file-0-body")).toBeVisible();

  await page.getByTestId(/^workspace-commit-diff-close-/).click();
  await expect(panel).toHaveCount(0);
  await commitRow.click();
-  await expect(panel.getByTestId("commit-diff-layout-split")).toHaveAttribute(
-    "aria-selected",
-    "true",
+  await expect(panel.getByTestId("commit-diff-toggle-layout")).toHaveAccessibleName(
+    "Switch to unified diff",
    { timeout: 30_000 },
  );

@@ -1,4 +1,4 @@
-import { writeFile } from "node:fs/promises";
+import { unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { type Page } from "@playwright/test";
 import { buildHostWorkspaceRoute, buildSettingsSectionRoute } from "../src/utils/host-routes";
@@ -10,6 +10,11 @@ import { waitForWorkspaceTabsVisible } from "./helpers/workspace-tabs";

 interface DirtyWorkspace {
  id: string;
+  repoPath: string;
+}
+
+interface WorkspaceFixtureOptions {
+  includeDeletedFile?: boolean;
 }

 interface CleanupTask {
@@ -218,6 +223,99 @@ test("changes diff keeps code rows aligned with the gutter", async ({ page }) =>
  });
 });

+test("changes file actions open from the kebab and right-click", async ({ page }) => {
+  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
+  await useUnwrappedDiffLines(page);
+  await openWorkspaceChanges(page, workspace);
+
+  await expect(page.getByTestId("diff-file-1")).toContainText("zz-deleted.ts");
+  await page.getByTestId("diff-file-1-actions").click();
+  await expect(page.getByText("Copy path")).toBeVisible();
+  await expect(page.getByTestId("diff-file-1-open-file")).toHaveCount(0);
+  await page.keyboard.press("Escape");
+
+  await page.getByTestId("diff-file-0-toggle").click({ button: "right" });
+  await expect(page.getByTestId("diff-file-0-open-file")).toBeVisible();
+  await page.getByTestId("diff-file-0-open-file").click();
+
+  await expect(page.getByTestId("workspace-file-pane")).toBeVisible();
+  await expect(page.getByTestId("workspace-tab-file_src/use-mounted-tab-set.ts")).toBeVisible();
+});
+
+test("Changes switches between inline and full-tab navigation", async ({ page }) => {
+  const workspace = await createWorkspaceWithMountedTabDiff({ includeDeletedFile: true });
+  await useUnwrappedDiffLines(page);
+  await openWorkspaceChanges(page, workspace);
+
+  const changesTabToggle = page.getByTestId("changes-open-tab");
+  await expect(changesTabToggle).toHaveAccessibleName("Open Changes tab");
+  await changesTabToggle.click();
+  await expect(changesTabToggle).toHaveAccessibleName("Close Changes tab");
+
+  const visiblePanel = page.getByTestId("working-diff-panel").filter({ visible: true });
+  await expect(visiblePanel).toBeVisible();
+  await expect(visiblePanel.getByText("use-mounted-tab-set.ts", { exact: true })).toBeVisible();
+  await expect(visiblePanel).toContainText("zz-deleted.ts");
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
+  await expect(page.getByTestId("workspace-file-pane")).toHaveCount(0);
+  await visiblePanel.getByTestId("diff-file-0-toggle").click();
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toHaveCount(0);
+  await visiblePanel.getByTestId("diff-file-0-toggle").click();
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
+  const workingDiffLayoutToggle = visiblePanel.getByTestId("working-diff-toggle-layout");
+  await expect(workingDiffLayoutToggle).toHaveAccessibleName("Switch to side-by-side diff");
+  await workingDiffLayoutToggle.click();
+  await expect(workingDiffLayoutToggle).toHaveAccessibleName("Switch to unified diff");
+  await visiblePanel.getByTestId("working-diff-options-menu").click();
+  await expect(page.getByTestId("working-diff-toggle-whitespace")).toContainText("Hide whitespace");
+  await expect(page.getByTestId("working-diff-toggle-wrap-lines")).toContainText("Wrap long lines");
+  await expect(page.getByTestId("working-diff-refresh")).toContainText("Refresh");
+  await page.getByTestId("working-diff-toggle-wrap-lines").click();
+  await visiblePanel.getByTestId("working-diff-options-menu").click();
+  await expect(page.getByTestId("working-diff-toggle-wrap-lines")).toContainText(
+    "Scroll long lines",
+  );
+  await page.keyboard.press("Escape");
+  await visiblePanel.getByTestId("working-diff-toggle-expand-all").click();
+  await expect(visiblePanel.getByTestId(/^diff-file-\d+-body$/)).toHaveCount(0);
+  await visiblePanel.getByTestId("working-diff-toggle-expand-all").click();
+  await expect(visiblePanel.getByTestId("diff-file-0-body")).toBeVisible();
+
+  await page.getByTestId("explorer-content-area").getByTestId("diff-file-0-toggle").click();
+  await expect(
+    page.getByTestId("explorer-content-area").getByTestId("diff-file-0-body"),
+  ).toHaveCount(0);
+  await expect(page.getByTestId(/^workspace-working-diff-close-/)).toHaveCount(1);
+
+  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), BEFORE);
+  await expect(visiblePanel.getByText("use-mounted-tab-set.ts", { exact: true })).toHaveCount(0, {
+    timeout: 30_000,
+  });
+  await expect(visiblePanel).toContainText("zz-deleted.ts");
+  await writeFile(path.join(workspace.repoPath, "src/use-mounted-tab-set.ts"), AFTER);
+  await expect(visiblePanel.getByText("use-mounted-tab-set.ts", { exact: true })).toBeVisible({
+    timeout: 30_000,
+  });
+
+  await expect(page.getByTestId("explorer-content-area").getByTestId("diff-file-1")).toContainText(
+    "zz-deleted.ts",
+  );
+  await page.getByTestId("explorer-content-area").getByTestId("diff-file-1-toggle").click();
+  await expect(page.getByTestId(/^workspace-working-diff-close-/)).toHaveCount(1);
+  await expect(visiblePanel.getByText("zz-deleted.ts", { exact: true })).toBeVisible();
+  await expect(visiblePanel).toContainText("Deleted");
+
+  await changesTabToggle.click();
+  await expect(page.getByTestId(/^workspace-working-diff-close-/)).toHaveCount(0);
+  await expect(
+    page.getByTestId("explorer-content-area").getByTestId("diff-file-0-body"),
+  ).toBeVisible();
+  await page.getByTestId("explorer-content-area").getByTestId("diff-file-0-toggle").click();
+  await expect(
+    page.getByTestId("explorer-content-area").getByTestId("diff-file-0-body"),
+  ).toHaveCount(0);
+});
+
 test("changes diff switches between flat and tree file lists", async ({ page }) => {
  const workspace = await createWorkspaceWithMountedTabDiff();
  await useUnwrappedDiffLines(page);
@@ -243,6 +341,11 @@ test("changes diff switches between flat and tree file lists", async ({ page })
  await expect(page.getByTestId("diff-folder-src")).toBeVisible();
  await expect(page.getByTestId("diff-file-0")).toBeVisible();

+  await page.getByRole("button", { name: "Collapse all" }).click();
+  await expect(page.getByTestId("diff-file-0")).toHaveCount(0);
+  await page.getByRole("button", { name: "Expand all" }).click();
+  await expect(page.getByTestId("diff-file-0-body")).toBeVisible();
+
  await page.getByTestId("diff-folder-src-toggle").click();
  await expect(page.getByTestId("diff-file-0")).toHaveCount(0);

@@ -250,6 +353,53 @@ test("changes diff switches between flat and tree file lists", async ({ page })
  await expectFlatFileList(page);
 });

+test("workspace file panes keep their controls on shared alignment rails", async ({ page }) => {
+  const workspace = await createWorkspaceWithMountedTabDiff();
+  await openWorkspaceChanges(page, workspace);
+
+  await page.getByTestId("changes-toggle-view-mode").click();
+  await expect(page.getByTestId("diff-folder-src")).toBeVisible();
+
+  const changesRightRail = await Promise.all([
+    readSvgRight(page, "explorer-close"),
+    readSvgRight(page, "changes-options-menu"),
+    readSvgRight(page, "diff-file-0-actions"),
+  ]);
+  expectAligned(changesRightRail);
+
+  const [folderStat, fileStat] = await Promise.all([
+    page.getByTestId("diff-folder-src-stat").boundingBox(),
+    page.getByTestId("diff-file-0-stat").boundingBox(),
+  ]);
+  expect(folderStat).not.toBeNull();
+  expect(fileStat).not.toBeNull();
+  expect(folderStat!.x + folderStat!.width).toBeCloseTo(fileStat!.x + fileStat!.width, 0);
+
+  await page.getByTestId("explorer-tab-files").click();
+  await expect(page.getByTestId("file-explorer-row-0")).toBeVisible();
+
+  const filesRightRail = await Promise.all([
+    readSvgRight(page, "explorer-close"),
+    readSvgRight(page, "files-refresh"),
+    readSvgRight(page, "file-explorer-row-0-actions"),
+  ]);
+  expectAligned(filesRightRail);
+
+  const [sortLabel, firstRowIcon, treeBounds, rowBounds] = await Promise.all([
+    page.getByTestId("files-sort-label").boundingBox(),
+    page.getByTestId("file-explorer-row-0").locator("svg").first().boundingBox(),
+    page.getByTestId("file-explorer-tree-scroll").boundingBox(),
+    page.getByTestId("file-explorer-row-0").boundingBox(),
+  ]);
+  expect(sortLabel).not.toBeNull();
+  expect(firstRowIcon).not.toBeNull();
+  expect(treeBounds).not.toBeNull();
+  expect(rowBounds).not.toBeNull();
+  expect(sortLabel!.x).toBeCloseTo(firstRowIcon!.x, 0);
+  expect(rowBounds!.x).toBeCloseTo(treeBounds!.x, 0);
+  expect(rowBounds!.x + rowBounds!.width).toBeCloseTo(treeBounds!.x + treeBounds!.width, 0);
+});
+
 test("changes diff keeps unwrapped gutter and code rows aligned after code size changes", async ({
  page,
 }) => {
@@ -399,10 +549,14 @@ async function readVisibleDiffRowGeometry(page: Page): Promise<{
  });
 }

-async function createWorkspaceWithMountedTabDiff(): Promise<DirtyWorkspace> {
-  const repo = await createTempGitRepo("diff-row-alignment-", {
-    files: [{ path: "src/use-mounted-tab-set.ts", content: BEFORE }],
-  });
+async function createWorkspaceWithMountedTabDiff(
+  options: WorkspaceFixtureOptions = {},
+): Promise<DirtyWorkspace> {
+  const files = [{ path: "src/use-mounted-tab-set.ts", content: BEFORE }];
+  if (options.includeDeletedFile) {
+    files.push({ path: "src/zz-deleted.ts", content: "export const deleted = true;\n" });
+  }
+  const repo = await createTempGitRepo("diff-row-alignment-", { files });
  const client = await connectSeedClient();
  cleanupTasks.push({
    run: async () => {
@@ -412,13 +566,16 @@ async function createWorkspaceWithMountedTabDiff(): Promise<DirtyWorkspace> {
  });

  await writeFile(path.join(repo.path, "src/use-mounted-tab-set.ts"), AFTER);
+  if (options.includeDeletedFile) {
+    await unlink(path.join(repo.path, "src/zz-deleted.ts"));
+  }
  const createdWorkspace = await client.createWorkspace({
    source: { kind: "directory", path: repo.path },
  });
  if (!createdWorkspace.workspace) {
    throw new Error(createdWorkspace.error ?? `Failed to create workspace ${repo.path}`);
  }
-  return { id: createdWorkspace.workspace.id };
+  return { id: createdWorkspace.workspace.id, repoPath: repo.path };
 }

 async function openWorkspaceChanges(page: Page, workspace: DirtyWorkspace): Promise<void> {
@@ -436,6 +593,21 @@ async function openChangesInVisibleExplorer(page: Page): Promise<void> {
  await expect(page.getByText("use-mounted-tab-set.ts")).toBeVisible({ timeout: 30_000 });
 }

+async function readSvgRight(page: Page, testID: string): Promise<number> {
+  const box = await page.getByTestId(testID).locator("svg").first().boundingBox();
+  if (!box) {
+    throw new Error(`Could not measure ${testID}`);
+  }
+  return box.x + box.width;
+}
+
+function expectAligned(values: number[]): void {
+  const [first, ...rest] = values;
+  for (const value of rest) {
+    expect(value).toBeCloseTo(first, 0);
+  }
+}
+
 async function expectExpandedMountedTabDiff(page: Page): Promise<void> {
  await expect(page.getByTestId("diff-file-0-body")).toBeVisible({ timeout: 30_000 });
  await expect(page.getByText("function createInitialMountedTabIds")).toBeVisible({
@@ -0,0 +1,19 @@
+import { test } from "./fixtures";
+import { DirectoryBootstrapScenario } from "./helpers/directory-bootstrap-scenario";
+
+test.describe("Directory bootstrap correctness", () => {
+  test("connect, pushed deltas, and reconnect keep directories current without duplicate bootstraps", async ({
+    page,
+  }) => {
+    test.setTimeout(180_000);
+    const scenario = await DirectoryBootstrapScenario.open(page);
+    try {
+      await scenario.expectDirectoryStarts(1);
+      await scenario.stayConnectedWithoutRefetchAndApplyDeltas();
+      await scenario.disconnectMutateAndReconnect();
+      await scenario.expectVisibleReconciliationAndNavigateAgent();
+    } finally {
+      await scenario.cleanup();
+    }
+  });
+});
@@ -219,15 +219,20 @@ test.describe("Project remove", () => {

      const readded = await workspace.client.addProject(workspace.repoPath);
      expect(readded.error).toBeNull();
+      expect(readded.project).not.toBeNull();
+      const readdedProjectId = readded.project?.projectId ?? "";
+      expect(readdedProjectId).not.toBe(workspace.projectId);
      expect(readded.project?.projectDisplayName).toBe(workspace.projectDisplayName);

      await page.reload();
      await waitForSidebarHydration(page);
-      await expect(projectRow).toBeVisible({ timeout: 30_000 });
-      await expect(projectRow).toContainText(workspace.projectDisplayName);
-      await expect(projectRow).not.toContainText(workspace.repoPath);
+      await expect(projectRow).toHaveCount(0, { timeout: 30_000 });
+      const readdedProjectRow = page.getByTestId(`sidebar-project-row-${readdedProjectId}`);
+      await expect(readdedProjectRow).toBeVisible({ timeout: 30_000 });
+      await expect(readdedProjectRow).toContainText(workspace.projectDisplayName);
+      await expect(readdedProjectRow).not.toContainText(workspace.repoPath);
      await expect(
-        page.getByTestId(`sidebar-project-new-workspace-row-${workspace.projectId}`),
+        page.getByTestId(`sidebar-project-new-workspace-row-${readdedProjectId}`),
      ).toBeVisible({ timeout: 30_000 });
    } finally {
      await workspace.cleanup();
@@ -0,0 +1,333 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { expect, test, type Page } from "./fixtures";
+import { openFileExplorer, openFileFromExplorer, expectFileTabOpen } from "./helpers/file-explorer";
+import { installDaemonWebSocketGate } from "./helpers/daemon-websocket-gate";
+import { openAgentRoute, seedMockAgentWorkspace } from "./helpers/mock-agent";
+
+const RED_PIXEL = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9Y9ZQmcAAAAASUVORK5CYII=",
+  "base64",
+);
+const BLUE_PIXEL = Buffer.from(
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
+  "base64",
+);
+
+function editor(page: Page) {
+  return page.getByTestId("file-source-editor").filter({ visible: true }).locator(".cm-content");
+}
+
+async function replaceEditorText(page: Page, content: string): Promise<void> {
+  const contentElement = editor(page);
+  await contentElement.click();
+  await contentElement.press("Control+A");
+  await contentElement.type(content);
+}
+
+async function openWorkspaceFile(page: Page, filename: string): Promise<void> {
+  const tree = page.getByTestId("file-explorer-tree-scroll");
+  if (!(await tree.isVisible())) await openFileExplorer(page);
+  await openFileFromExplorer(page, filename);
+  await expectFileTabOpen(page, filename);
+}
+
+async function seedAgentWithFileLink(target: string) {
+  const session = await seedMockAgentWorkspace({
+    repoPrefix: "file-editing-chat-link-",
+    title: "Chat file link e2e",
+    initialPrompt: [
+      "Generate a title and a git branch name for a coding agent from the user prompt and attachments.",
+      "Return JSON only with fields 'title' and 'branch'.",
+      "",
+      "<user-prompt>",
+      `Open \`${target}\` now`,
+      "</user-prompt>",
+    ].join("\n"),
+  });
+  await writeFile(
+    path.join(session.cwd, "target.ts"),
+    Array.from({ length: 80 }, (_, index) => `export const line${index + 1} = ${index + 1};`).join(
+      "\n",
+    ),
+    "utf8",
+  );
+  return session;
+}
+
+test.describe("CodeMirror workspace file editing", () => {
+  test("opens an assistant file link at its referenced line", async ({ page }) => {
+    const target = "target.ts:42";
+    const session = await seedAgentWithFileLink(target);
+
+    try {
+      await openAgentRoute(page, session);
+
+      const fileLink = page.getByText(target, { exact: true });
+      await expect(fileLink).toBeVisible({ timeout: 15_000 });
+      await fileLink.click();
+
+      await expectFileTabOpen(page, "target.ts");
+      await expect(page.getByTestId("file-source-editor")).toBeVisible();
+      await expect(page.getByLabel("Line 42, column 1")).toBeVisible();
+      await expect(
+        page.getByTestId("file-source-editor").locator(".cm-line", { hasText: "line42 = 42" }),
+      ).toBeVisible();
+
+      const sourceEditor = editor(page);
+      await sourceEditor.click();
+      await sourceEditor.press("Control+Home");
+      await expect(page.getByLabel(/^Line 1, column \d+$/)).toBeVisible();
+
+      await page
+        .getByTestId(`workspace-tab-agent_${session.agentId}`)
+        .filter({ visible: true })
+        .click();
+      await expect(fileLink).toBeVisible();
+      await fileLink.click();
+
+      await expect(page.getByLabel("Line 42, column 1")).toBeVisible();
+      await expect(
+        page.getByTestId("file-source-editor").locator(".cm-line", { hasText: "line42 = 42" }),
+      ).toBeVisible();
+    } finally {
+      await session.cleanup();
+    }
+  });
+
+  test("shows the full file path and keeps editor controls stable", async ({
+    page,
+    withWorkspace,
+  }) => {
+    await page.emulateMedia({ colorScheme: "dark" });
+    const workspace = await withWorkspace({ prefix: "file-editing-visuals-" });
+    const relativePath = "src/deep/visuals.md";
+    const sourcePath = path.join(workspace.repoPath, relativePath);
+    await mkdir(path.dirname(sourcePath), { recursive: true });
+    await writeFile(
+      sourcePath,
+      [...Array.from({ length: 11 }, (_, index) => `line ${index + 1}`), "abcdefghijklmnop"].join(
+        "\n",
+      ),
+      "utf8",
+    );
+    await workspace.navigateTo();
+    await openFileExplorer(page);
+    await page.getByTestId("file-explorer-tree-scroll").getByText("src", { exact: true }).click();
+    await page.getByTestId("file-explorer-tree-scroll").getByText("deep", { exact: true }).click();
+    await openFileFromExplorer(page, "visuals.md");
+    await expectFileTabOpen(page, relativePath);
+
+    const fileTab = page.getByTestId(`workspace-tab-file_${relativePath}`).first();
+    await fileTab.hover();
+    await expect(page.getByTestId(`workspace-tab-tooltip-file_${relativePath}`)).toHaveText(
+      relativePath,
+    );
+    await expect(page.getByTestId("file-panel-bar")).not.toContainText("visuals.md");
+    const modeControl = page.getByTestId("file-markdown-mode");
+    await expect(modeControl).toBeVisible();
+    await page.getByTestId("file-mode-source").click();
+
+    const editorHost = page.getByTestId("file-source-editor");
+    const content = editor(page);
+    await expect(editorHost).toHaveAttribute("data-pmono", "");
+    await expect(content).toHaveCSS("font-family", /SFMono-Regular/);
+
+    await content.click();
+    const cursor = editorHost.locator(".cm-cursor-primary");
+    await expect(cursor).toBeVisible();
+    await expect(cursor).toHaveCSS("border-left-color", "rgb(250, 250, 250)");
+
+    const initialModeBox = await modeControl.boundingBox();
+    expect(initialModeBox).not.toBeNull();
+    const initialModeX = initialModeBox!.x;
+    await content.press("Control+End");
+    await expect(page.getByLabel(/Line 12, column \d+/)).toBeVisible();
+    const movedModeBox = await modeControl.boundingBox();
+    expect(movedModeBox).not.toBeNull();
+    expect(movedModeBox!.x).toBe(initialModeX);
+
+    await content.press("Control+a");
+    const selection = editorHost.locator(".cm-selectionBackground").first();
+    await expect(selection).toBeVisible();
+    await expect(selection).toHaveCSS("background-color", "rgba(255, 255, 255, 0.2)");
+  });
+
+  test("applies the interface font to portaled tooltips", async ({ page, withWorkspace }) => {
+    await page.addInitScript(() => {
+      localStorage.setItem("@paseo:app-settings", JSON.stringify({ uiFontFamily: "monospace" }));
+    });
+    const workspace = await withWorkspace({ prefix: "file-tooltip-font-" });
+    const relativePath = "tooltip-font.txt";
+    await writeFile(path.join(workspace.repoPath, relativePath), "tooltip font\n", "utf8");
+    await workspace.navigateTo();
+    await openFileExplorer(page);
+    await openFileFromExplorer(page, relativePath);
+    await expectFileTabOpen(page, relativePath);
+
+    await page.getByTestId(`workspace-tab-file_${relativePath}`).first().hover();
+
+    await expect(
+      page
+        .getByTestId(`workspace-tab-tooltip-file_${relativePath}`)
+        .getByText(relativePath, { exact: true }),
+    ).toHaveCSS("font-family", "monospace");
+  });
+
+  test("autosaves, saves immediately, resolves conflicts, and restores live updates after reconnect", async ({
+    page,
+    withWorkspace,
+  }) => {
+    test.setTimeout(120_000);
+    const gate = await installDaemonWebSocketGate(page);
+    const workspace = await withWorkspace({ prefix: "file-editing-source-" });
+    const sourcePath = path.join(workspace.repoPath, "source.ts");
+    await writeFile(sourcePath, "const initial = 1;\n", "utf8");
+    await Promise.all(
+      ["one.ts", "two.ts", "three.ts", "four.ts"].map((fileName) =>
+        writeFile(path.join(workspace.repoPath, fileName), `// ${fileName}\n`, "utf8"),
+      ),
+    );
+    await workspace.navigateTo();
+    await openWorkspaceFile(page, "source.ts");
+
+    await expect(page.getByTestId("file-source-editor")).toBeVisible();
+    await expect(page.getByLabel(/File size/)).toBeVisible();
+    await expect(page.getByLabel(/lines/)).toBeVisible();
+
+    await replaceEditorText(page, "const autosaved = 2;\n");
+    await expect(page.getByTestId("workspace-tab-modified-file_source.ts")).toBeVisible();
+    await expect(page.getByLabel("Editor status dirty")).toBeVisible();
+    await expect(page.getByLabel("Editor status clean")).toBeVisible({ timeout: 5_000 });
+    await expect(page.getByTestId("workspace-tab-modified-file_source.ts")).not.toBeVisible();
+    await expect.poll(() => readFile(sourcePath, "utf8")).toBe("const autosaved = 2;\n");
+
+    await replaceEditorText(page, "const immediate = 3;\n");
+    await editor(page).press("Control+s");
+    await expect.poll(() => readFile(sourcePath, "utf8")).toBe("const immediate = 3;\n");
+
+    await writeFile(sourcePath, "const external = 4;\nconst line = 2;\n", "utf8");
+    await expect(editor(page)).toContainText("const external = 4;");
+    await expect(page.getByLabel("3 lines")).toBeVisible();
+
+    await replaceEditorText(page, "const localWins = 5;\n");
+    await writeFile(sourcePath, "const diskLoses = 6;\n", "utf8");
+    await expect(page.getByTestId("file-conflict-alert")).toBeVisible();
+    for (const fileName of ["one.ts", "two.ts", "three.ts", "four.ts"]) {
+      await openWorkspaceFile(page, fileName);
+    }
+    await page.getByTestId("workspace-tab-file_source.ts").filter({ visible: true }).click();
+    await expect(editor(page)).toContainText("const localWins = 5;");
+    await expect(page.getByTestId("file-conflict-alert")).toBeVisible();
+    await page.getByRole("button", { name: "Overwrite", exact: true }).click();
+    await expect.poll(() => readFile(sourcePath, "utf8")).toBe("const localWins = 5;\n");
+
+    await replaceEditorText(page, "const discarded = 7;\n");
+    await writeFile(sourcePath, "const diskWins = 8;\n", "utf8");
+    await expect(page.getByTestId("file-conflict-alert")).toBeVisible();
+    page.once("dialog", (dialog) => dialog.accept());
+    await page.getByRole("button", { name: "Reload", exact: true }).click();
+    await expect(editor(page)).toContainText("const diskWins = 8;");
+
+    const subscriptionCount = gate.getClientRequestCount("fs.file.subscribe.request");
+    await gate.drop();
+    gate.restore();
+    await expect
+      .poll(() => gate.getClientRequestCount("fs.file.subscribe.request"), { timeout: 30_000 })
+      .toBeGreaterThan(subscriptionCount);
+    await writeFile(sourcePath, "const afterReconnect = 9;\n", "utf8");
+    await expect(editor(page)).toContainText("const afterReconnect = 9;");
+  });
+
+  test("warns before closing a panel with an unsaved draft", async ({ page, withWorkspace }) => {
+    const workspace = await withWorkspace({ prefix: "file-editing-draft-" });
+    const sourcePath = path.join(workspace.repoPath, "draft.ts");
+    await writeFile(sourcePath, "const initial = 1;\n", "utf8");
+    await workspace.navigateTo();
+    await openWorkspaceFile(page, "draft.ts");
+
+    await replaceEditorText(page, "const local = 2;\n");
+    await writeFile(sourcePath, "const external = 3;\n", "utf8");
+    await expect(page.getByTestId("file-conflict-alert")).toBeVisible();
+    await expect(page.getByTestId("workspace-tab-modified-file_draft.ts")).toBeVisible();
+
+    let closePrompt = "";
+    page.once("dialog", async (dialog) => {
+      closePrompt = dialog.message();
+      await dialog.dismiss();
+    });
+    await page
+      .getByTestId("workspace-tab-file_draft.ts")
+      .filter({ visible: true })
+      .first()
+      .click({ button: "right" });
+    await page
+      .getByTestId("workspace-tab-context-file_draft.ts-close")
+      .filter({ visible: true })
+      .click();
+    expect(closePrompt).toContain("Closing it will discard the draft.");
+
+    await expect(page.getByTestId("file-source-editor")).toBeVisible();
+    await expect(page.getByTestId("workspace-tab-modified-file_draft.ts")).toBeVisible();
+  });
+
+  test("refreshes Markdown and images while preserving Preview and Source behavior", async ({
+    page,
+    withWorkspace,
+  }) => {
+    test.setTimeout(90_000);
+    const workspace = await withWorkspace({ prefix: "file-editing-preview-" });
+    const markdownPath = path.join(workspace.repoPath, "notes.md");
+    const imagePath = path.join(workspace.repoPath, "pixel.png");
+    await writeFile(markdownPath, "# First heading\n", "utf8");
+    await writeFile(imagePath, RED_PIXEL);
+    await workspace.navigateTo();
+    await openWorkspaceFile(page, "notes.md");
+
+    await expect(page.getByText("First heading", { exact: true })).toBeVisible();
+    await expect(page.getByTestId("file-markdown-mode")).toBeVisible();
+    await writeFile(markdownPath, "# Updated heading\n", "utf8");
+    await expect(page.getByText("Updated heading", { exact: true })).toBeVisible();
+
+    await page.getByTestId("file-mode-source").click();
+    await expect(page.getByTestId("file-source-editor")).toBeVisible();
+    await replaceEditorText(page, "# Saved from source\n");
+    await expect.poll(() => readFile(markdownPath, "utf8")).toBe("# Saved from source\n");
+    await page.getByTestId("file-mode-preview").click();
+    await expect(page.getByText("Saved from source", { exact: true })).toBeVisible();
+
+    await openWorkspaceFile(page, "pixel.png");
+    const image = page.getByTestId("workspace-file-pane").locator("img");
+    await expect(image).toBeVisible();
+    const initialSource = await image.getAttribute("src");
+    await writeFile(imagePath, BLUE_PIXEL);
+    await expect.poll(() => image.getAttribute("src")).not.toBe(initialSource);
+  });
+
+  test("persists Vim keybindings and reports Vim mode with cursor position", async ({
+    page,
+    withWorkspace,
+  }) => {
+    test.setTimeout(90_000);
+    const workspace = await withWorkspace({ prefix: "file-editing-vim-" });
+    await writeFile(path.join(workspace.repoPath, "vim.ts"), "const vim = true;\n", "utf8");
+
+    await page.goto("/settings/editor");
+    const toggle = page.getByRole("switch", { name: "Vim keybindings" });
+    await expect(toggle).toBeVisible();
+    await toggle.click();
+    await expect(toggle).toBeChecked();
+    await page.reload();
+    await expect(page.getByRole("switch", { name: "Vim keybindings" })).toBeChecked();
+
+    await workspace.navigateTo();
+    await openWorkspaceFile(page, "vim.ts");
+    await expect(page.getByLabel("Vim mode NORMAL")).toBeVisible();
+    await expect(page.getByLabel("Line 1, column 1")).toBeVisible();
+    await editor(page).click();
+    await editor(page).press("i");
+    await expect(page.getByLabel("Vim mode INSERT")).toBeVisible();
+    await editor(page).press("Escape");
+    await expect(page.getByLabel("Vim mode NORMAL")).toBeVisible();
+  });
+});
@@ -14,7 +14,7 @@ import { withDisabledE2ESpeechEnv } from "./helpers/speech-env";

 const wranglerCliPath = path.resolve(__dirname, "../node_modules/wrangler/bin/wrangler.js");

-interface WaitForServerOptions {
+export interface WaitForServerOptions {
  host?: string;
  timeoutMs?: number;
  label: string;
@@ -22,6 +22,8 @@ interface WaitForServerOptions {
  getRecentOutput?: () => string;
 }

+type ServerProbe = (host: string, port: number) => Promise<void>;
+
 async function getAvailablePort(): Promise<number> {
  return new Promise((resolve, reject) => {
    const server = net.createServer();
@@ -75,7 +77,25 @@ function sleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
 }

-async function waitForServer(port: number, options: WaitForServerOptions): Promise<void> {
+async function connectToServer(host: string, port: number): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const socket = net.connect(port, host, () => {
+      socket.end();
+      resolve();
+    });
+    socket.setTimeout(1000, () => {
+      socket.destroy();
+      reject(new Error(`Connection timed out to ${host}:${port}`));
+    });
+    socket.on("error", reject);
+  });
+}
+
+async function waitForServer(
+  port: number,
+  options: WaitForServerOptions,
+  probe: ServerProbe = connectToServer,
+): Promise<void> {
  const { host = "127.0.0.1", timeoutMs = 15000, label, childProcess, getRecentOutput } = options;
  const start = Date.now();
  let lastConnectionError: unknown = null;
@@ -89,17 +109,7 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
    }

    try {
-      await new Promise<void>((resolve, reject) => {
-        const socket = net.connect(port, host, () => {
-          socket.end();
-          resolve();
-        });
-        socket.setTimeout(1000, () => {
-          socket.destroy();
-          reject(new Error(`Connection timed out to ${host}:${port}`));
-        });
-        socket.on("error", reject);
-      });
+      await probe(host, port);
      return;
    } catch (error) {
      lastConnectionError = error;
@@ -116,6 +126,22 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
  );
 }

+async function probeMetro(host: string, port: number): Promise<void> {
+  const response = await fetch(`http://${host}:${port}/status`, {
+    signal: AbortSignal.timeout(1000),
+  });
+  const body = (await response.text()).trim();
+  if (response.status !== 200 || body !== "packager-status:running") {
+    throw new Error(
+      `Expected Metro status on ${host}:${port}, received HTTP ${response.status}: ${JSON.stringify(body.slice(0, 200))}`,
+    );
+  }
+}
+
+export async function waitForMetro(port: number, options: WaitForServerOptions): Promise<void> {
+  await waitForServer(port, options, probeMetro);
+}
+
 function parseRelayStartupFailure(line: string): string | null {
  const clean = stripAnsi(line);
  if (/Address already in use/i.test(clean)) {
@@ -302,6 +328,12 @@ interface PairingDaemonClient {

 async function createFakeEditorBin(): Promise<string> {
  const binDir = await mkdtemp(path.join(tmpdir(), "paseo-e2e-editor-bin-"));
+  let realGhPath = "";
+  try {
+    realGhPath = execSync("which gh").toString().trim();
+  } catch {
+    // The local PR fixture below remains usable without a system gh binary.
+  }

  const fakeEditorSource = `#!/usr/bin/env node
 const fs = require("fs");
@@ -323,6 +355,70 @@ if (recordPath) {
    await chmod(editorPath, 0o755);
  }

+  const fakeGhPath = path.join(binDir, "gh");
+  const fakeGhSource = `#!/usr/bin/env node
+const { spawnSync } = require("child_process");
+const args = process.argv.slice(2);
+const fixtureRemote = "https://github.com/paseo-e2e/local-fixture.git";
+const origin = spawnSync("git", ["config", "--get", "remote.origin.url"], {
+  encoding: "utf8",
+  stdio: ["ignore", "pipe", "ignore"]
+}).stdout?.trim();
+
+if (origin === fixtureRemote) {
+  const command = args.slice(0, 2).join(" ");
+  if (command === "auth status") process.exit(0);
+  if (command === "repo view") {
+    process.stdout.write(JSON.stringify({ owner: { login: "paseo-e2e" }, name: "local-fixture", parent: null }));
+    process.exit(0);
+  }
+  if (command === "issue list") {
+    process.stdout.write("[]");
+    process.exit(0);
+  }
+  if (command === "pr list" || command === "pr view") {
+    const pr = {
+      number: 1,
+      title: "Use pasted PR as start ref",
+      url: "https://github.com/paseo-e2e/local-fixture/pull/1",
+      state: "OPEN",
+      body: null,
+      labels: [],
+      baseRefName: "main",
+      headRefName: "pr-branch-1",
+      updatedAt: "2026-01-01T00:00:00Z"
+    };
+    process.stdout.write(JSON.stringify(command === "pr list" ? [pr] : pr));
+    process.exit(0);
+  }
+  if (command === "api graphql" && args.some((arg) => arg.includes("PullRequestCheckoutTarget"))) {
+    process.stdout.write(JSON.stringify({
+      data: { repository: { pullRequest: {
+        number: 1,
+        baseRefName: "main",
+        headRefName: "pr-branch-1",
+        isCrossRepository: false,
+        headRepositoryOwner: { login: "paseo-e2e" },
+        headRepository: {
+          sshUrl: "git@github.com:paseo-e2e/local-fixture.git",
+          url: fixtureRemote
+        }
+      } } }
+    }));
+    process.exit(0);
+  }
+  process.stderr.write("Unsupported local GitHub fixture command: " + args.join(" ") + "\\n");
+  process.exit(1);
+}
+
+const realGhPath = ${JSON.stringify(realGhPath)};
+if (!realGhPath) process.exit(127);
+const result = spawnSync(realGhPath, args, { stdio: "inherit" });
+process.exit(result.status ?? 1);
+`;
+  await writeFile(fakeGhPath, fakeGhSource);
+  await chmod(fakeGhPath, 0o755);
+
  return binDir;
 }

@@ -556,13 +652,19 @@ async function getAvailablePortExcluding(excludedPorts: Set<number>): Promise<nu
  }
 }

-async function startRelay(excludedPorts: Set<number>): Promise<number> {
+interface RelayPorts {
+  relayPort: number;
+  inspectorPort: number;
+}
+
+async function startRelay(excludedPorts: Set<number>): Promise<RelayPorts> {
  const relayDir = path.resolve(__dirname, "..", "..", "relay");
  const maxRelayStartupAttempts = 5;
  let lastRelayStartupError: unknown = null;

  for (let attempt = 1; attempt <= maxRelayStartupAttempts; attempt += 1) {
    const relayPort = await getAvailablePortExcluding(excludedPorts);
+    const inspectorPort = await getAvailablePortExcluding(new Set([...excludedPorts, relayPort]));
    const buffer = createLineBuffer();
    const state: RelayStreamState = { failureLine: null, readyForSelectedPort: false };

@@ -576,6 +678,10 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {
        "127.0.0.1",
        "--port",
        String(relayPort),
+        "--inspector-ip",
+        "127.0.0.1",
+        "--inspector-port",
+        String(inspectorPort),
        "--live-reload=false",
        "--show-interactive-dev-session=false",
      ],
@@ -590,7 +696,7 @@ async function startRelay(excludedPorts: Set<number>): Promise<number> {

    try {
      await awaitRelayReady(relayProcess, relayPort, state, buffer);
-      return relayPort;
+      return { relayPort, inspectorPort };
    } catch (error) {
      lastRelayStartupError = error;
      await stopProcess(relayProcess);
@@ -767,12 +873,19 @@ export default async function globalSetup() {
  await logSpeechHarnessConfig();

  try {
-    const relayPort = await startRelay(new Set([port, metroPort]));
    metroProcess = startMetro({
      metroPort,
      daemonPort: port,
      buffer: metroLineBuffer,
    });
+    await waitForMetro(metroPort, {
+      label: "Metro web server",
+      timeoutMs: 120000,
+      childProcess: metroProcess,
+      getRecentOutput: metroLineBuffer.dump,
+    });
+
+    const { relayPort, inspectorPort } = await startRelay(new Set([port, metroPort]));
    daemonProcess = startDaemon({
      port,
      relayPort,
@@ -783,19 +896,11 @@ export default async function globalSetup() {
      buffer: daemonLineBuffer,
    });

-    await Promise.all([
-      waitForServer(port, {
-        label: "Paseo daemon",
-        childProcess: daemonProcess,
-        getRecentOutput: daemonLineBuffer.dump,
-      }),
-      waitForServer(metroPort, {
-        label: "Metro web server",
-        timeoutMs: 120000,
-        childProcess: metroProcess,
-        getRecentOutput: metroLineBuffer.dump,
-      }),
-    ]);
+    await waitForServer(port, {
+      label: "Paseo daemon",
+      childProcess: daemonProcess,
+      getRecentOutput: daemonLineBuffer.dump,
+    });

    const offer = await waitForPairingOfferFromDaemon({
      port,
@@ -809,7 +914,7 @@ export default async function globalSetup() {
    process.env.E2E_PASEO_HOME = paseoHome;
    process.env.E2E_EDITOR_RECORD_PATH = editorRecordPath;
    console.log(
-      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, home: ${paseoHome}`,
+      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, relay on port ${relayPort}, relay inspector on port ${inspectorPort}, home: ${paseoHome}`,
    );

    return async () => {
@@ -26,13 +26,14 @@ interface E2EDaemonClientConfig {
  webSocketFactory?: NodeWebSocketFactory;
 }

-function resolveDaemonWsUrl(): string {
-  return `ws://127.0.0.1:${getE2EDaemonPort()}/ws`;
+function resolveDaemonWsUrl(port?: number): string {
+  return `ws://127.0.0.1:${port ?? getE2EDaemonPort()}/ws`;
 }

 export interface ConnectDaemonClientOptions {
  clientIdPrefix: string;
  appVersion?: string;
+  port?: number;
 }

 /**
@@ -45,7 +46,7 @@ export async function connectDaemonClient<ClientInstance extends { connect(): Pr
 ): Promise<ClientInstance> {
  const DaemonClient = await loadDaemonClientConstructor<E2EDaemonClientConfig, ClientInstance>();
  const client = new DaemonClient({
-    url: resolveDaemonWsUrl(),
+    url: resolveDaemonWsUrl(options.port),
    clientId: `${options.clientIdPrefix}-${randomUUID()}`,
    clientType: "cli",
    appVersion: options.appVersion ?? loadAppVersion(),
@@ -1,159 +0,0 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import { createRequire } from "node:module";
-import { readFile } from "node:fs/promises";
-import net from "node:net";
-import path from "node:path";
-
-import { getE2EDaemonPort } from "./daemon-port";
-import { withDisabledE2ESpeechEnv } from "./speech-env";
-
-/**
- * Restarts the isolated E2E daemon against the SAME PASEO_HOME and SAME port so
- * persisted state reloads and existing clients can reconnect. This exercises the
- * post-restart rehydration path (the daemon rebuilding workspace/agent links
- * from disk), which is where the worktree-branch regression lives.
- *
- * The daemon is owned by Playwright's `globalSetup`, which keeps its child
- * handle in module scope we can't reach from a spec. Instead we drive it the
- * same way an operator would: read the supervisor PID from
- * `$PASEO_HOME/paseo.pid`, SIGTERM it (the supervisor forwards the signal to its
- * worker and releases the lock), wait for the port to free, then re-spawn the
- * supervisor with the identical environment globalSetup used. The relay and
- * Metro processes are untouched, so we reuse their already-published ports.
- *
- * This NEVER targets the developer daemon: the port comes from
- * `getE2EDaemonPort()`, which refuses 6767, and PASEO_HOME is the isolated E2E
- * home globalSetup created.
- */
-
-function getEnvOrThrow(name: string): string {
-  const value = process.env[name];
-  if (!value) {
-    throw new Error(`${name} is not set (expected from Playwright globalSetup).`);
-  }
-  return value;
-}
-
-async function readSupervisorPid(paseoHome: string): Promise<number> {
-  const pidPath = path.join(paseoHome, "paseo.pid");
-  const content = await readFile(pidPath, "utf8");
-  const parsed = JSON.parse(content) as { pid?: unknown };
-  if (typeof parsed.pid !== "number") {
-    throw new Error(`Malformed PID lock at ${pidPath}: ${content}`);
-  }
-  return parsed.pid;
-}
-
-function isPidRunning(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function isPortListening(port: number, host = "127.0.0.1"): Promise<boolean> {
-  return new Promise((resolve) => {
-    const socket = net.connect(port, host, () => {
-      socket.end();
-      resolve(true);
-    });
-    socket.setTimeout(1000, () => {
-      socket.destroy();
-      resolve(false);
-    });
-    socket.on("error", () => resolve(false));
-  });
-}
-
-async function waitUntil(
-  predicate: () => Promise<boolean> | boolean,
-  options: { timeoutMs: number; label: string },
-): Promise<void> {
-  const deadline = Date.now() + options.timeoutMs;
-  while (Date.now() < deadline) {
-    if (await predicate()) {
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  throw new Error(`Timed out after ${options.timeoutMs}ms waiting for ${options.label}.`);
-}
-
-function spawnSupervisor(args: {
-  paseoHome: string;
-  port: string;
-  relayPort: string;
-  metroPort: string;
-  editorRecordPath: string;
-}): ChildProcess {
-  const serverDir = path.resolve(__dirname, "../../../..", "packages/server");
-  // Run the supervisor through the resolved tsx CLI under the current node
-  // binary. Spawning the `node_modules/.bin/tsx` shim directly is unreliable
-  // inside the Playwright worker (the shim is a .mjs symlink, not an executable),
-  // so resolve the CLI module and load it with node.
-  const tsxCli = createRequire(path.join(serverDir, "package.json")).resolve("tsx/cli");
-  const env = withDisabledE2ESpeechEnv({
-    ...process.env,
-    PASEO_HOME: args.paseoHome,
-    PASEO_E2E_EDITOR_RECORD_PATH: args.editorRecordPath,
-    PASEO_SERVER_ID: "srv_e2e_test_daemon",
-    PASEO_LISTEN: `0.0.0.0:${args.port}`,
-    PASEO_RELAY_ENDPOINT: `127.0.0.1:${args.relayPort}`,
-    PASEO_CORS_ORIGINS: `http://localhost:${args.metroPort}`,
-    PASEO_NODE_ENV: "development",
-    NODE_ENV: "development",
-  });
-
-  const child = spawn(process.execPath, [tsxCli, "scripts/supervisor-entrypoint.ts", "--dev"], {
-    cwd: serverDir,
-    env,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: false,
-  });
-
-  child.stdout?.on("data", (data: Buffer) => {
-    for (const line of data.toString().split("\n")) {
-      if (line.trim()) console.log(`[daemon:restart] ${line.trim()}`);
-    }
-  });
-  child.stderr?.on("data", (data: Buffer) => {
-    for (const line of data.toString().split("\n")) {
-      if (line.trim()) console.error(`[daemon:restart] ${line.trim()}`);
-    }
-  });
-
-  // Detach our handles so the spawned supervisor outlives this spec process and
-  // is reaped by globalSetup's cleanup (the original process tree), not us.
-  child.unref();
-  return child;
-}
-
-export async function restartTestDaemon(): Promise<void> {
-  const port = getE2EDaemonPort();
-  const paseoHome = getEnvOrThrow("E2E_PASEO_HOME");
-  const relayPort = getEnvOrThrow("E2E_RELAY_PORT");
-  const metroPort = getEnvOrThrow("E2E_METRO_PORT");
-  const editorRecordPath =
-    process.env.E2E_EDITOR_RECORD_PATH ?? path.join(paseoHome, "editor-open-records.jsonl");
-
-  const pid = await readSupervisorPid(paseoHome);
-  process.kill(pid, "SIGTERM");
-
-  await waitUntil(() => !isPidRunning(pid), {
-    timeoutMs: 15_000,
-    label: `supervisor PID ${pid} to exit`,
-  });
-  await waitUntil(async () => !(await isPortListening(Number(port))), {
-    timeoutMs: 15_000,
-    label: `port ${port} to free`,
-  });
-
-  spawnSupervisor({ paseoHome, port, relayPort, metroPort, editorRecordPath });
-
-  await waitUntil(async () => isPortListening(Number(port)), {
-    timeoutMs: 30_000,
-    label: `restarted daemon to listen on port ${port}`,
-  });
-}
@@ -0,0 +1,114 @@
+import type { Page, WebSocketRoute } from "@playwright/test";
+import { daemonWsRoutePattern } from "./daemon-port";
+
+export interface DirectoryBootstrapCounts {
+  agents: number;
+  workspaces: number;
+}
+
+export interface DirectoryRequestStartCounts {
+  subscribed: DirectoryBootstrapCounts;
+  unsubscribed: DirectoryBootstrapCounts;
+  total: DirectoryBootstrapCounts;
+}
+
+interface ClientRequest {
+  type?: unknown;
+  subscribe?: unknown;
+  page?: { cursor?: unknown };
+}
+
+function readClientRequest(message: string | Buffer): ClientRequest | null {
+  if (typeof message !== "string") return null;
+  try {
+    const envelope = JSON.parse(message) as {
+      type?: unknown;
+      message?: ClientRequest;
+    };
+    return envelope.type === "session" ? (envelope.message ?? null) : envelope;
+  } catch {
+    return null;
+  }
+}
+
+function directoryForRequest(request: ClientRequest): keyof DirectoryBootstrapCounts | null {
+  if (request.page?.cursor) return null;
+  if (request.type === "fetch_agents_request") return "agents";
+  if (request.type === "fetch_workspaces_request") return "workspaces";
+  return null;
+}
+
+export async function installDaemonWebSocketGate(page: Page) {
+  let acceptingConnections = true;
+  const activeSockets = new Set<WebSocketRoute>();
+  const directoryStarts: DirectoryRequestStartCounts = {
+    subscribed: { agents: 0, workspaces: 0 },
+    unsubscribed: { agents: 0, workspaces: 0 },
+    total: { agents: 0, workspaces: 0 },
+  };
+  const clientRequestCounts = new Map<string, number>();
+
+  await page.routeWebSocket(daemonWsRoutePattern(), (ws) => {
+    if (!acceptingConnections) {
+      void ws.close({ code: 1008, reason: "Blocked by reconnect test." });
+      return;
+    }
+
+    activeSockets.add(ws);
+    const server = ws.connectToServer();
+
+    ws.onMessage((message) => {
+      if (!acceptingConnections) return;
+      const request = readClientRequest(message);
+      if (typeof request?.type === "string") {
+        clientRequestCounts.set(request.type, (clientRequestCounts.get(request.type) ?? 0) + 1);
+        const directory = directoryForRequest(request);
+        if (directory) {
+          const subscription = request.subscribe === undefined ? "unsubscribed" : "subscribed";
+          directoryStarts[subscription][directory] += 1;
+          directoryStarts.total[directory] += 1;
+        }
+      }
+      try {
+        server.send(message);
+      } catch {
+        activeSockets.delete(ws);
+      }
+    });
+
+    server.onMessage((message) => {
+      if (!acceptingConnections) return;
+      try {
+        ws.send(message);
+      } catch {
+        activeSockets.delete(ws);
+      }
+    });
+  });
+
+  return {
+    async drop(): Promise<void> {
+      acceptingConnections = false;
+      const sockets = Array.from(activeSockets);
+      activeSockets.clear();
+      await Promise.all(
+        sockets.map((ws) =>
+          ws.close({ code: 1008, reason: "Dropped by reconnect test." }).catch(() => undefined),
+        ),
+      );
+    },
+    restore(): void {
+      acceptingConnections = true;
+    },
+    getDirectoryRequestStartCounts(): DirectoryRequestStartCounts {
+      return {
+        subscribed: { ...directoryStarts.subscribed },
+        unsubscribed: { ...directoryStarts.unsubscribed },
+        total: { ...directoryStarts.total },
+      };
+    },
+    getClientRequestCount(type: string): number {
+      return clientRequestCounts.get(type) ?? 0;
+    },
+  };
+}
@@ -65,6 +65,8 @@ export interface DesktopBridgeConfig {
  daemonListen?: string;
  /** Keep start_desktop_daemon pending to hold the desktop startup blocker open. */
  hangDaemonStart?: boolean;
+  /** Delay the desktop settings IPC response to exercise startup ordering. */
+  desktopSettingsDelayMs?: number;
  /**
   * Controls what dialog.ask returns when the daemon management confirm dialog
   * fires. True = confirm (proceed with the action), false = cancel. Defaults to
@@ -101,6 +103,7 @@ declare global {
    __capturedDialogCall: ConfirmDialogCall | undefined;
    __capturedDialogOpenCalls: Array<Record<string, unknown> | undefined>;
    __recordDesktopEditorOpen?: (input: DesktopEditorOpenRecord) => Promise<void>;
+    __desktopDaemonStartRequested?: boolean;
  }
 }

@@ -129,6 +132,7 @@ export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfi
    let daemonRunning = true;
    let currentPid: number | null = cfg.daemonPid ?? null;
    let startCount = 0;
+    window.__desktopDaemonStartRequested = false;

    function buildDaemonStatus() {
      return {
@@ -145,6 +149,7 @@ export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfi
    }

    function startDesktopDaemon() {
+      window.__desktopDaemonStartRequested = true;
      if (cfg.hangDaemonStart) {
        return new Promise(() => undefined);
      }
@@ -156,6 +161,13 @@ export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfi
      return buildDaemonStatus();
    }

+    async function waitForDesktopSettingsResponse() {
+      const delayMs = cfg.desktopSettingsDelayMs ?? 0;
+      if (delayMs > 0) {
+        await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+
    const desktopBridge: {
      platform: string;
      invoke: (command: string, args?: Record<string, unknown>) => Promise<unknown>;
@@ -212,6 +224,7 @@ export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfi
        }

        if (command === "get_desktop_settings") {
+          await waitForDesktopSettingsResponse();
          return {
            releaseChannel: "stable",
            daemon: { manageBuiltInDaemon: manageDaemon, keepRunningAfterQuit: true },
@@ -277,6 +290,17 @@ export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfi
  }, config);
 }

+export async function waitForDesktopDaemonStartRequest(page: Page): Promise<void> {
+  await page.waitForFunction(() => window.__desktopDaemonStartRequested === true);
+  // Give the startup state two paints to expose any app → splash regression.
+  await page.evaluate(
+    () =>
+      new Promise<void>((resolve) =>
+        requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
+      ),
+  );
+}
+
 export async function waitForDirectoryDialog(
  page: Page,
 ): Promise<Record<string, unknown> | undefined> {
@@ -0,0 +1,155 @@
+import { expect, type Page } from "@playwright/test";
+import { buildHostAgentDetailRoute } from "@/utils/host-routes";
+import { installDaemonWebSocketGate } from "./daemon-websocket-gate";
+import { seedWorkspace, type SeededWorkspace } from "./seed-client";
+import { getServerId } from "./server-id";
+import { waitForWorkspaceTabsVisible } from "./workspace-tabs";
+import { expectReconnectingToastGone, expectReconnectingToastVisible } from "./workspace-ui";
+
+interface SeededDirectoryAgent {
+  id: string;
+  title: string;
+}
+
+async function createRunningMockAgent(
+  workspace: SeededWorkspace,
+  title: string,
+): Promise<SeededDirectoryAgent> {
+  const agent = await workspace.client.createAgent({
+    provider: "mock",
+    cwd: workspace.repoPath,
+    workspaceId: workspace.workspaceId,
+    title,
+    modeId: "load-test",
+    model: "five-minute-stream",
+    initialPrompt: `Keep ${title} running for directory synchronization.`,
+  });
+  const running = await workspace.client.waitForAgentUpsert(
+    agent.id,
+    (snapshot) => snapshot.status === "running",
+    30_000,
+  );
+  expect(running.status).toBe("running");
+  return { id: agent.id, title };
+}
+
+async function openCommandCenter(page: Page): Promise<void> {
+  await page.getByRole("button", { name: "Open command center" }).click();
+}
+
+export class DirectoryBootstrapScenario {
+  private readonly workspaces: SeededWorkspace[] = [];
+  private disconnectedWorkspace: SeededWorkspace | null = null;
+  private disconnectedAgent: SeededDirectoryAgent | null = null;
+
+  private constructor(
+    private readonly page: Page,
+    private readonly gate: Awaited<ReturnType<typeof installDaemonWebSocketGate>>,
+  ) {}
+
+  static async open(page: Page): Promise<DirectoryBootstrapScenario> {
+    const gate = await installDaemonWebSocketGate(page);
+    const scenario = new DirectoryBootstrapScenario(page, gate);
+    const workspace = await scenario.seedWorkspace("directory-bootstrap-initial-");
+    const agent = await createRunningMockAgent(workspace, "Initial directory agent");
+    await page.goto(buildHostAgentDetailRoute(getServerId(), agent.id, workspace.workspaceId));
+    await page.waitForURL(
+      (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
+    );
+    await waitForWorkspaceTabsVisible(page);
+    await expect(page.getByRole("button", { name: agent.title, exact: true })).toBeVisible();
+    return scenario;
+  }
+
+  async expectDirectoryStarts(expectedPerDirectory: number): Promise<void> {
+    await expect
+      .poll(() => this.gate.getDirectoryRequestStartCounts())
+      .toEqual({
+        subscribed: { agents: expectedPerDirectory, workspaces: expectedPerDirectory },
+        unsubscribed: { agents: 0, workspaces: 0 },
+        total: { agents: expectedPerDirectory, workspaces: expectedPerDirectory },
+      });
+  }
+
+  async stayConnectedWithoutRefetchAndApplyDeltas(): Promise<void> {
+    const workspace = await this.seedWorkspace("directory-bootstrap-background-");
+    const agent = await createRunningMockAgent(workspace, "Background directory agent");
+
+    const workspaceLink = this.page.getByText(workspace.projectDisplayName, { exact: true });
+    await expect(workspaceLink).toHaveCount(1);
+    await expect(workspaceLink).toBeVisible();
+    await openCommandCenter(this.page);
+    const agentLink = this.page.getByText(agent.title, { exact: true });
+    await expect(agentLink).toHaveCount(1);
+    await expect(agentLink).toBeVisible();
+    await this.page.keyboard.press("Escape");
+    await this.expectDirectoryStarts(1);
+  }
+
+  async disconnectMutateAndReconnect(): Promise<void> {
+    await this.gate.drop();
+    await expectReconnectingToastVisible(this.page);
+
+    this.disconnectedWorkspace = await this.seedWorkspace("directory-bootstrap-reconnect-");
+    this.disconnectedAgent = await createRunningMockAgent(
+      this.disconnectedWorkspace,
+      "Reconnected directory agent",
+    );
+    await expect(
+      this.page.getByText(this.disconnectedWorkspace.projectDisplayName, { exact: true }),
+    ).toHaveCount(0);
+    await expect(this.page.getByText(this.disconnectedAgent.title, { exact: true })).toHaveCount(0);
+
+    this.gate.restore();
+    await expectReconnectingToastGone(this.page);
+    await this.expectDirectoryStarts(2);
+  }
+
+  async expectVisibleReconciliationAndNavigateAgent(): Promise<void> {
+    const workspace = this.requireDisconnectedWorkspace();
+    const agent = this.requireDisconnectedAgent();
+    const workspaceLink = this.page.getByText(workspace.projectDisplayName, { exact: true });
+    await expect(workspaceLink).toHaveCount(1);
+    await expect(workspaceLink).toBeVisible();
+    await openCommandCenter(this.page);
+    const agentLink = this.page.getByText(agent.title, { exact: true });
+    await expect(agentLink).toHaveCount(1);
+    await expect(agentLink).toBeVisible();
+    await agentLink.click();
+    await expect(this.page).toHaveURL(
+      new RegExp(
+        `/workspace/${workspace.workspaceId}/agent/${agent.id}|/workspace/${workspace.workspaceId}`,
+      ),
+    );
+    await expect(this.page.getByRole("button", { name: agent.title, exact: true })).toHaveAttribute(
+      "aria-selected",
+      "true",
+    );
+    const pings = this.gate.getClientRequestCount("ping");
+    await expect
+      .poll(() => this.gate.getClientRequestCount("ping"), { timeout: 30_000 })
+      .toBeGreaterThan(pings);
+    await this.expectDirectoryStarts(2);
+  }
+
+  async cleanup(): Promise<void> {
+    this.gate.restore();
+    await Promise.all(this.workspaces.map((workspace) => workspace.cleanup()));
+  }
+
+  private async seedWorkspace(prefix: string): Promise<SeededWorkspace> {
+    const workspace = await seedWorkspace({ repoPrefix: prefix });
+    this.workspaces.push(workspace);
+    return workspace;
+  }
+
+  private requireDisconnectedWorkspace(): SeededWorkspace {
+    if (!this.disconnectedWorkspace) throw new Error("Reconnect workspace was not seeded.");
+    return this.disconnectedWorkspace;
+  }
+
+  private requireDisconnectedAgent(): SeededDirectoryAgent {
+    if (!this.disconnectedAgent) throw new Error("Reconnect agent was not seeded.");
+    return this.disconnectedAgent;
+  }
+}
@@ -1,5 +1,5 @@
 import { execFileSync, execSync } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import path from "node:path";

 export function hasGithubAuth(): boolean {
@@ -59,6 +59,12 @@ export interface GhDefaultBranchClone {
  cleanup(): Promise<void>;
 }

+export interface LocalGhPrFixture {
+  pr: GhPrFixture;
+  mainCheckout: GhDefaultBranchClone;
+  cleanup(): Promise<void>;
+}
+
 function gh(args: string[], opts?: { cwd?: string }): string {
  return execFileSync("gh", args, {
    cwd: opts?.cwd,
@@ -281,3 +287,57 @@ export async function cloneGithubRepoDefaultBranchOnly(
    },
  };
 }
+
+export async function createLocalGithubPrFixture(): Promise<LocalGhPrFixture> {
+  const fixtureRoot = await mkdtemp(path.join("/tmp", "paseo-e2e-local-github-pr-"));
+  const basePath = path.join(fixtureRoot, "base");
+  const remotePath = path.join(fixtureRoot, "remote.git");
+  const checkoutPath = path.join(fixtureRoot, "main-only");
+  const githubUrl = "https://github.com/paseo-e2e/local-fixture.git";
+  await mkdir(basePath);
+
+  git(["init", "-b", "main"], basePath);
+  git(["config", "user.email", "e2e@paseo.test"], basePath);
+  git(["config", "user.name", "Paseo E2E"], basePath);
+  git(["config", "commit.gpgsign", "false"], basePath);
+  await writeFile(path.join(basePath, "README.md"), "# Local GitHub fixture\n");
+  git(["add", "README.md"], basePath);
+  git(["commit", "-m", "Initial commit"], basePath);
+  git(["checkout", "-b", "pr-branch-1"], basePath);
+  await writeFile(path.join(basePath, "pr-1.txt"), "PR 1\n");
+  git(["add", "pr-1.txt"], basePath);
+  git(["commit", "-m", "Add PR 1"], basePath);
+  git(["checkout", "main"], basePath);
+
+  execFileSync("git", ["clone", "--quiet", "--bare", basePath, remotePath], {
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  git(["update-ref", "refs/pull/1/head", "refs/heads/pr-branch-1"], remotePath);
+  execFileSync(
+    "git",
+    ["clone", "--quiet", "--single-branch", "--branch", "main", remotePath, checkoutPath],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  git(["remote", "set-url", "origin", githubUrl], checkoutPath);
+  git(["config", `url.${remotePath}.insteadOf`, githubUrl], checkoutPath);
+  git(["config", "user.email", "e2e@paseo.test"], checkoutPath);
+  git(["config", "user.name", "Paseo E2E"], checkoutPath);
+  git(["config", "commit.gpgsign", "false"], checkoutPath);
+
+  return {
+    pr: {
+      number: 1,
+      title: "Use pasted PR as start ref",
+      url: "https://github.com/paseo-e2e/local-fixture/pull/1",
+      branch: "pr-branch-1",
+      localPath: basePath,
+    },
+    mainCheckout: {
+      path: checkoutPath,
+      cleanup: async () => {},
+    },
+    cleanup: async () => {
+      await rm(fixtureRoot, { recursive: true, force: true });
+    },
+  };
+}
@@ -9,6 +9,7 @@ import { withDisabledE2ESpeechEnv } from "./speech-env";
 export interface IsolatedHostDaemon {
  serverId: string;
  port: number;
+  restart(): Promise<void>;
  close(): Promise<void>;
 }

@@ -85,43 +86,61 @@ export async function startIsolatedHostDaemon(serverId: string): Promise<Isolate
  const paseoHome = await mkdtemp(path.join(tmpdir(), "paseo-e2e-secondary-host-"));
  const serverDir = path.resolve(__dirname, "../../../server");
  const tsxBin = execSync("which tsx").toString().trim();
-  const child = spawn(tsxBin, ["scripts/supervisor-entrypoint.ts", "--dev"], {
-    cwd: serverDir,
-    env: withDisabledE2ESpeechEnv({
-      ...process.env,
-      PASEO_HOME: paseoHome,
-      PASEO_SERVER_ID: serverId,
-      PASEO_LISTEN: `127.0.0.1:${port}`,
-      PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
-      PASEO_RELAY_ENABLED: "0",
-      PASEO_NODE_ENV: "development",
-      NODE_ENV: "development",
-    }),
-    stdio: ["ignore", "ignore", "pipe"],
-    detached: false,
-  });
+  const spawnDaemon = async (): Promise<ChildProcess> => {
+    const child = spawn(tsxBin, ["scripts/supervisor-entrypoint.ts", "--dev"], {
+      cwd: serverDir,
+      env: withDisabledE2ESpeechEnv({
+        ...process.env,
+        PASEO_HOME: paseoHome,
+        PASEO_SERVER_ID: serverId,
+        PASEO_LISTEN: `127.0.0.1:${port}`,
+        PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
+        PASEO_RELAY_ENABLED: "0",
+        PASEO_NODE_ENV: "development",
+        NODE_ENV: "development",
+      }),
+      stdio: ["ignore", "ignore", "pipe"],
+      detached: false,
+    });

-  let stderr = "";
-  child.stderr?.on("data", (chunk: Buffer) => {
-    stderr += chunk.toString("utf8");
-    stderr = stderr.split("\n").slice(-40).join("\n");
-  });
+    let stderr = "";
+    child.stderr?.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString("utf8");
+      stderr = stderr.split("\n").slice(-40).join("\n");
+    });

+    try {
+      await waitForServer(port, child);
+      return child;
+    } catch (error) {
+      await stopProcess(child);
+      throw new Error(
+        `${error instanceof Error ? error.message : String(error)}\nDaemon stderr:\n${stderr}`,
+        { cause: error },
+      );
+    }
+  };
+
+  let child: ChildProcess;
  try {
-    await waitForServer(port, child);
+    child = await spawnDaemon();
  } catch (error) {
-    await stopProcess(child);
    await rm(paseoHome, { recursive: true, force: true });
-    throw new Error(
-      `${error instanceof Error ? error.message : String(error)}\nDaemon stderr:\n${stderr}`,
-      { cause: error },
-    );
+    throw error;
  }
+  let closed = false;

  return {
    serverId,
    port,
+    restart: async () => {
+      if (closed) throw new Error(`Cannot restart closed isolated daemon ${serverId}`);
+      await stopProcess(child);
+      child = await spawnDaemon();
+    },
    close: async () => {
+      if (closed) return;
+      closed = true;
      await stopProcess(child);
      await rm(paseoHome, { recursive: true, force: true });
    },
@@ -1,4 +1,4 @@
-import { expect, type Page } from "@playwright/test";
+import { expect, type BrowserContext, type Page } from "@playwright/test";
 import type { DaemonClient as InternalDaemonClient } from "@getpaseo/client/internal/daemon-client";
 import { decodeWorkspaceIdFromPathSegment } from "@/utils/host-routes";
 import { connectDaemonClient } from "./daemon-client-loader";
@@ -89,9 +89,12 @@ function parseWorkspaceIdFromPageUrl(page: Page, serverId: string): string | nul
  return decodeWorkspaceIdFromPathSegment(match[1]);
 }

-export async function connectNewWorkspaceDaemonClient(): Promise<NewWorkspaceDaemonClient> {
+export async function connectNewWorkspaceDaemonClient(options?: {
+  port?: number;
+}): Promise<NewWorkspaceDaemonClient> {
  return connectDaemonClient<NewWorkspaceDaemonClient>({
    clientIdPrefix: "app-e2e-new-workspace",
+    port: options?.port,
  });
 }

@@ -287,6 +290,13 @@ export async function selectBranchInPicker(page: Page, name: string): Promise<vo
  await branchRow.click();
 }

+export async function searchAndSelectBranchInPicker(page: Page, name: string): Promise<void> {
+  const searchInput = page.getByPlaceholder("Search branches and PRs");
+  await expect(searchInput).toBeVisible({ timeout: 30_000 });
+  await searchInput.fill(name);
+  await selectBranchInPicker(page, name);
+}
+
 export async function selectGitHubPrInPicker(page: Page, number: number): Promise<void> {
  const prRow = page.getByTestId(`new-workspace-ref-picker-pr-${number}`);
  await expect(prRow).toBeVisible({ timeout: 30_000 });
@@ -348,6 +358,18 @@ export async function expectComposerGithubAttachmentPill(
  await expect(pills.first()).toContainText(input.title);
 }

+export async function pasteGithubPrUrl(
+  page: Page,
+  context: BrowserContext,
+  url: string,
+): Promise<void> {
+  const composer = page.getByRole("textbox", { name: "Message agent..." });
+  await context.grantPermissions(["clipboard-read", "clipboard-write"]);
+  await page.evaluate((value) => navigator.clipboard.writeText(value), url);
+  await composer.focus();
+  await page.keyboard.press("Control+V");
+}
+
 export async function assertNewWorkspaceSidebarAndHeader(
  page: Page,
  input: {
@@ -144,7 +144,7 @@ export interface SeedDaemonClient {
  } | null;
  fetchAgentHistory(options?: {
    page?: { limit: number };
-  }): Promise<{ entries: Array<{ id: string }> }>;
+  }): Promise<{ entries: Array<{ agent: { id: string } }> }>;
  subscribeTerminal(
    terminalId: string,
  ): Promise<{ terminalId: string; slot: number; error: null } | { error: string }>;
@@ -158,10 +158,11 @@ export interface SeedDaemonClient {
  killTerminal(terminalId: string): Promise<{ error: string | null }>;
 }

-export async function connectSeedClient(): Promise<SeedDaemonClient> {
+export async function connectSeedClient(options?: { port?: number }): Promise<SeedDaemonClient> {
  return connectDaemonClient<SeedDaemonClient>({
    clientIdPrefix: "seed",
    appVersion: loadAppVersion(),
+    port: options?.port,
  });
 }

@@ -22,6 +22,7 @@ interface SavedSettingsHostInput {
 const SECTION_LABELS = {
  general: "General",
  appearance: "Appearance",
+  editor: "Editor",
  shortcuts: "Shortcuts",
  integrations: "Integrations",
  permissions: "Permissions",
@@ -39,6 +39,13 @@ export async function clickArchiveWorkspaceMenuItem(
  await archiveItem.click();
 }

+export async function pinWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
+  const serverId = await openWorkspaceSidebarKebab(page, workspaceId);
+  const pinItem = page.getByTestId(`sidebar-workspace-menu-pin-${serverId}:${workspaceId}`);
+  await expect(pinItem).toBeVisible({ timeout: 10_000 });
+  await pinItem.click();
+}
+
 export async function archiveWorkspaceFromSidebar(page: Page, workspaceId: string): Promise<void> {
  // A clean workspace archives with no prompt. Managed worktree backing may raise
  // a browser confirm for unsynced work, so accept it when present.
@@ -0,0 +1,55 @@
+import { expect, type Page } from "@playwright/test";
+
+type WebSocketMessage = string | Buffer;
+
+interface SessionMessage {
+  type?: unknown;
+  payload?: unknown;
+}
+
+interface TimelineSubscriptionWaitOptions {
+  timeout?: number;
+}
+
+function readSessionMessage(message: WebSocketMessage): SessionMessage | null {
+  if (typeof message !== "string") return null;
+  try {
+    const envelope = JSON.parse(message) as {
+      type?: unknown;
+      message?: SessionMessage;
+    };
+    return envelope.type === "session" ? (envelope.message ?? null) : envelope;
+  } catch {
+    return null;
+  }
+}
+
+export function observeTimelineSubscriptions(page: Page) {
+  let acknowledgedAgentIds: string[] | null = null;
+
+  page.on("websocket", (socket) => {
+    socket.on("framereceived", ({ payload }) => {
+      const message = readSessionMessage(payload);
+      if (message?.type !== "agent.timeline.set_subscription.response") return;
+      const response = message.payload as { agentIds?: unknown } | undefined;
+      if (!Array.isArray(response?.agentIds)) return;
+      acknowledgedAgentIds = response.agentIds.filter(
+        (agentId): agentId is string => typeof agentId === "string",
+      );
+    });
+  });
+
+  return {
+    async waitForSubscribedAgents(
+      agentIds: string[],
+      options: TimelineSubscriptionWaitOptions = {},
+    ): Promise<void> {
+      const expected = [...new Set(agentIds)].sort();
+      await expect
+        .poll(() => acknowledgedAgentIds?.slice().sort() ?? null, {
+          timeout: options.timeout ?? 15_000,
+        })
+        .toEqual(expected);
+    },
+  };
+}
@@ -17,11 +17,14 @@ import {
  expectPickerOpen,
  expectPickerSelected,
  expectStartingRefPickerTriggerPr,
+  fillNewWorkspaceDraft,
  openGlobalNewWorkspaceComposer,
  openBranchPicker,
  openNewWorkspaceComposer,
  openProjectViaDaemon,
  openStartingRefPicker,
+  pasteGithubPrUrl,
+  searchAndSelectBranchInPicker,
  selectBranchInPicker,
  selectGitHubPrInPicker,
  selectPickerOptionByKeyboard,
@@ -30,9 +33,11 @@ import {
 } from "./helpers/new-workspace";
 import { createTempGitRepo, readWorktreeBranchInfo } from "./helpers/workspace";
 import {
+  createLocalGithubPrFixture,
  cloneGithubRepoDefaultBranchOnly,
  createTempGithubRepo,
  hasGithubAuth,
+  type LocalGhPrFixture,
 } from "./helpers/github-fixtures";
 import { getServerId } from "./helpers/server-id";
 import { getE2EDaemonPort } from "./helpers/daemon-port";
@@ -191,6 +196,7 @@ test.describe("New workspace flow", () => {
  let client: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
  const localWorkspaceIds = new Set<string>();
  const createdWorktreeDirectories = new Set<string>();
+  const localGithubFixtures = new Set<LocalGhPrFixture>();

  test.describe.configure({ timeout: 240_000 });

@@ -212,6 +218,13 @@ test.describe("New workspace flow", () => {
    await client?.close().catch(() => undefined);
  });

+  test.afterAll(async () => {
+    for (const fixture of localGithubFixtures) {
+      await fixture.cleanup();
+    }
+    localGithubFixtures.clear();
+  });
+
  test("adds a project from the selected empty host", async ({ page }) => {
    const repo = await createTempGitRepo("new-workspace-project-picker-");
    const primaryServerId = getServerId();
@@ -807,6 +820,100 @@ test.describe("New workspace flow", () => {
    }
  });

+  test("pasted GitHub PR replaces a selected branch and creates its worktree", async ({
+    page,
+    context,
+  }) => {
+    const fixture = await createLocalGithubPrFixture();
+    localGithubFixtures.add(fixture);
+    const { pr, mainCheckout } = fixture;
+
+    const openedProject = await openProjectViaDaemon(client, mainCheckout.path);
+    localWorkspaceIds.add(openedProject.workspaceId);
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await openNewWorkspaceComposer(page, {
+      projectKey: openedProject.projectKey,
+      projectDisplayName: openedProject.projectDisplayName,
+    });
+    await selectWorkspaceIsolation(page, "worktree");
+    await openStartingRefPicker(page);
+    await selectBranchInPicker(page, "main");
+
+    await pasteGithubPrUrl(page, context, pr.url);
+
+    await expect(page.getByTestId("workspace-create-submit")).toBeDisabled();
+    await expectComposerGithubAttachmentPill(page, {
+      number: pr.number,
+      title: pr.title,
+    });
+    await expectStartingRefPickerTriggerPr(page, {
+      number: pr.number,
+      title: pr.title,
+      headRef: pr.branch,
+    });
+
+    await submitNewWorkspaceWithoutPrompt(page);
+
+    const worktree = await assertNewWorkspaceSidebarAndHeader(page, {
+      serverId: getServerId(),
+      client,
+      previousWorkspaceId: openedProject.workspaceId,
+      projectDisplayName: openedProject.projectDisplayName,
+    });
+    createdWorktreeDirectories.add(worktree.workspaceDirectory);
+
+    const branchInfo = await readWorktreeBranchInfo({
+      worktreePath: worktree.workspaceDirectory,
+    });
+    expect(branchInfo.currentBranch).toBe(pr.branch);
+    expect(existsSync(path.join(worktree.workspaceDirectory, "pr-1.txt"))).toBe(true);
+  });
+
+  test("branches remain searchable after a pasted PR and determine the created worktree", async ({
+    page,
+    context,
+  }) => {
+    const fixture = await createLocalGithubPrFixture();
+    localGithubFixtures.add(fixture);
+    const { pr, mainCheckout } = fixture;
+
+    const openedProject = await openProjectViaDaemon(client, mainCheckout.path);
+    localWorkspaceIds.add(openedProject.workspaceId);
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await openNewWorkspaceComposer(page, {
+      projectKey: openedProject.projectKey,
+      projectDisplayName: openedProject.projectDisplayName,
+    });
+    await selectWorkspaceIsolation(page, "worktree");
+    await pasteGithubPrUrl(page, context, pr.url);
+    await expectStartingRefPickerTriggerPr(page, {
+      number: pr.number,
+      title: pr.title,
+      headRef: pr.branch,
+    });
+
+    await openStartingRefPicker(page);
+    await searchAndSelectBranchInPicker(page, "main");
+    await expectPickerSelected(page, "main");
+    await fillNewWorkspaceDraft(page, `${pr.url}\nKeep this checkout on main`);
+    await expectPickerSelected(page, "main");
+    await submitNewWorkspaceWithoutPrompt(page);
+
+    const worktree = await assertNewWorkspaceSidebarAndHeader(page, {
+      serverId: getServerId(),
+      client,
+      previousWorkspaceId: openedProject.workspaceId,
+      projectDisplayName: openedProject.projectDisplayName,
+    });
+    createdWorktreeDirectories.add(worktree.workspaceDirectory);
+
+    expect(existsSync(path.join(worktree.workspaceDirectory, "pr-1.txt"))).toBe(false);
+  });
+
  test("selected GitHub PR creates the worktree from the PR head even when the head branch is not fetched", async ({
    page,
  }) => {
@@ -208,7 +208,7 @@ test.describe("Projects settings", () => {
    page,
    gitlabRemoteProject,
  }) => {
-    expect(gitlabRemoteProject.name).toBe("acme/app");
+    expect(gitlabRemoteProject.name).toBe(path.basename(gitlabRemoteProject.path));
    await openProjects(page);
    await openProjectSettings(page, gitlabRemoteProject.name);
    await editWorktreeSetup(page, updatedSetup);
@@ -81,6 +81,32 @@ test("opens support and release destinations", async ({ page }) => {
  await expectExternalPage(page, "sidebar-help-changelog", CHANGELOG_DESTINATION);
 });

+test("searches keyboard shortcuts from the sidebar help menu", async ({ page }) => {
+  await page.addInitScript(() => {
+    Object.defineProperty(navigator, "platform", { get: () => "MacIntel" });
+  });
+  await gotoAppShell(page);
+  await openHelpMenu(page);
+  await page.getByTestId("sidebar-help-shortcuts").click();
+
+  const dialog = page.getByTestId("keyboard-shortcuts-dialog");
+  const search = page.getByPlaceholder("Search shortcuts");
+
+  await search.fill("command+n");
+  await expect(dialog.getByText("New workspace", { exact: true })).toBeVisible();
+
+  await search.fill("interrupt");
+
+  await expect(dialog.getByText("Interrupt agent", { exact: true })).toBeVisible();
+  await expect(dialog.getByText("New workspace", { exact: true })).toHaveCount(0);
+
+  await search.fill("no matching shortcut");
+  await expect(dialog.getByText("No results found", { exact: true })).toBeVisible();
+
+  await search.fill("");
+  await expect(dialog.getByText("New workspace", { exact: true })).toBeVisible();
+});
+
 test("keeps diagnostics available from Settings after globalizing the sheet", async ({ page }) => {
  await gotoAppShell(page);
  await openSettings(page);
@@ -6,6 +6,7 @@ import {
  expectMobileAgentSidebarHidden,
  expectMobileAgentSidebarVisible,
  openMobileAgentSidebar,
+  pinWorkspaceFromSidebar,
 } from "./helpers/sidebar";
 import { seedWorkspace } from "./helpers/seed-client";
 import { expectWorkspaceHeader } from "./helpers/workspace-ui";
@@ -46,24 +47,25 @@ async function waitForSidebarWorkspace(page: import("@playwright/test").Page, wo
 }

 test.describe("Sidebar workspace list", () => {
-  test("project with GitHub remote shows owner/repo name in sidebar", async ({ page }) => {
+  test("project with GitHub remote shows its selected folder name in sidebar", async ({ page }) => {
    const workspace = await seedWorkspace({
      repoPrefix: "sidebar-remote-",
      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
    });

    try {
+      const projectName = path.basename(workspace.repoPath);
      await gotoAppShell(page);
-      await waitForSidebarProject(page, "test-owner/test-repo");
+      await waitForSidebarProject(page, projectName);
      await waitForSidebarWorkspace(page, workspace.workspaceId);

      const projectRow = page
        .locator('[data-testid^="sidebar-project-row-"]')
-        .filter({ hasText: "test-owner/test-repo" })
+        .filter({ hasText: projectName })
        .first();

      await expect(projectRow).toBeVisible({ timeout: 30_000 });
-      await expect(projectRow).not.toContainText(path.basename(workspace.repoPath));
+      await expect(projectRow).not.toContainText("test-owner/test-repo");
    } finally {
      await workspace.cleanup();
    }
@@ -96,21 +98,24 @@ test.describe("Sidebar workspace list", () => {
    }
  });

-  test("workspace header shows correct title and subtitle", async ({ page }) => {
+  test("workspace header uses the selected folder name instead of its GitHub remote", async ({
+    page,
+  }) => {
    const workspace = await seedWorkspace({
      repoPrefix: "sidebar-header-",
      repo: { withRemote: true, originUrl: GITHUB_REMOTE_URL },
    });

    try {
+      const projectName = path.basename(workspace.repoPath);
      await gotoAppShell(page);
-      await waitForSidebarProject(page, "test-owner/test-repo");
+      await waitForSidebarProject(page, projectName);
      await waitForSidebarWorkspace(page, workspace.workspaceId);
      await openWorkspaceFromSidebar(page, workspace.workspaceId);

      await expectWorkspaceHeader(page, {
        title: workspace.workspaceName,
-        subtitle: "test-owner/test-repo",
+        subtitle: projectName,
      });
    } finally {
      await workspace.cleanup();
@@ -164,6 +169,30 @@ test.describe("Mobile sidebar panelState transition", () => {
    await closeMobileAgentSidebar(page);
    await expectMobileAgentSidebarHidden(page);
  });
+
+  test("keeps a pinned workspace rendered while the retained sidebar is closed", async ({
+    page,
+  }) => {
+    const workspace = await seedWorkspace({ repoPrefix: "sidebar-retained-pin-" });
+
+    try {
+      await gotoAppShell(page);
+      await openMobileAgentSidebar(page);
+      await expectMobileAgentSidebarVisible(page);
+
+      const row = page.getByTestId(getWorkspaceRowTestId(workspace.workspaceId));
+      await expect(row).toBeVisible({ timeout: 30_000 });
+      await pinWorkspaceFromSidebar(page, workspace.workspaceId);
+      await expect(page.getByTestId("sidebar-pinned-section")).toBeVisible();
+
+      await closeMobileAgentSidebar(page);
+      await expectMobileAgentSidebarHidden(page);
+
+      await expect(row).toHaveCount(1);
+    } finally {
+      await workspace.cleanup();
+    }
+  });
 });

 test.describe("Half-screen desktop layout", () => {
@@ -190,6 +219,7 @@ test.describe("Half-screen desktop layout", () => {
      }

      await gotoAppShell(page);
+      await page.getByTestId(`sidebar-project-show-more-${workspace.projectId}`).click();
      await waitForSidebarWorkspace(page, lastWorkspaceId);

      const sidebarScroll = page.getByTestId("sidebar-project-workspace-list-scroll");
@@ -15,7 +15,7 @@ import { getServerId } from "./helpers/server-id";
 *
 * The repro is the mundane user flow: with a workspace already showing a terminal, open another
 * one and switch to a different app while it spawns. We stage the blur deterministically by
- * stubbing `document.hasFocus()` (which `useAppVisible` consults on window focus/blur events)
+ * stubbing `document.hasFocus()` (which `useAppActivelyVisible` consults on focus/blur events)
 * instead of racing real OS focus.
 *
 * The assertion reads the PTY's own opinion of its size (`stty size`) with input written
@@ -23,7 +23,7 @@ import { getServerId } from "./helpers/server-id";
 */

 /**
- * Simulates the window losing/regaining OS focus, which is what `useAppVisible` reads through
+ * Simulates the window losing/regaining OS focus, which is what `useAppActivelyVisible` reads through
 * `document.hasFocus()` plus the window focus/blur events.
 *
 * This has to be stubbed: headless Chromium never actually blurs. Opening a second page and
@@ -0,0 +1,179 @@
+import { expect, type Page } from "@playwright/test";
+import { buildHostAgentDetailRoute } from "@/utils/host-routes";
+import { test } from "./fixtures";
+import { seedWorkspace, type SeedDaemonClient } from "./helpers/seed-client";
+import { getServerId } from "./helpers/server-id";
+import { observeTimelineSubscriptions } from "./helpers/timeline-delivery";
+import { waitForWorkspaceTabsVisible } from "./helpers/workspace-tabs";
+import { installDaemonWebSocketGate } from "./helpers/daemon-websocket-gate";
+import {
+  expectReconnectingToastGone,
+  expectReconnectingToastVisible,
+} from "./helpers/workspace-ui";
+
+interface ViewedTimelineScenario {
+  client: SeedDaemonClient;
+  workspaceId: string;
+  firstAgentId: string;
+  secondAgentId: string;
+  cleanup(): Promise<void>;
+}
+
+async function seedViewedTimelineScenario(): Promise<ViewedTimelineScenario> {
+  const workspace = await seedWorkspace({ repoPrefix: "viewed-timelines-" });
+  const createAgent = (title: string) =>
+    workspace.client.createAgent({
+      provider: "mock",
+      cwd: workspace.repoPath,
+      workspaceId: workspace.workspaceId,
+      title,
+      modeId: "load-test",
+      model: "ten-second-stream",
+    });
+  const [firstAgent, secondAgent] = await Promise.all([
+    createAgent("First viewed chat"),
+    createAgent("Second viewed chat"),
+  ]);
+  return {
+    client: workspace.client,
+    workspaceId: workspace.workspaceId,
+    firstAgentId: firstAgent.id,
+    secondAgentId: secondAgent.id,
+    cleanup: workspace.cleanup,
+  };
+}
+
+async function openAgent(page: Page, scenario: ViewedTimelineScenario, agentId: string) {
+  await page.goto(buildHostAgentDetailRoute(getServerId(), agentId, scenario.workspaceId));
+  await page.waitForURL(
+    (url) => url.pathname.includes("/workspace/") && !url.searchParams.has("open"),
+  );
+  await waitForWorkspaceTabsVisible(page);
+}
+
+async function selectAgent(page: Page, title: string) {
+  await page.getByRole("button", { name: title, exact: true }).click();
+}
+
+async function enableMoveTabShortcut(page: Page) {
+  await page.addInitScript(() => {
+    Object.defineProperty(navigator, "platform", { get: () => "MacIntel" });
+  });
+}
+
+async function moveActiveTabRight(page: Page) {
+  await page.keyboard.press("Meta+Alt+Shift+ArrowRight");
+}
+
+async function commitMessage(scenario: ViewedTimelineScenario, agentId: string, prompt: string) {
+  await scenario.client.sendAgentMessage(agentId, prompt);
+  const finish = await scenario.client.waitForFinish(agentId, 30_000);
+  expect(finish.status).toBe("idle");
+}
+
+test.describe("Viewed agent timelines", () => {
+  test("an unsubscribed hidden chat catches up when shown", async ({ page }) => {
+    test.setTimeout(90_000);
+    const subscriptions = observeTimelineSubscriptions(page);
+    const scenario = await seedViewedTimelineScenario();
+    try {
+      await openAgent(page, scenario, scenario.firstAgentId);
+      await selectAgent(page, "Second viewed chat");
+      await subscriptions.waitForSubscribedAgents([scenario.secondAgentId], { timeout: 45_000 });
+      await commitMessage(
+        scenario,
+        scenario.firstAgentId,
+        "Committed after the first chat unsubscribed.",
+      );
+      await expect(
+        page.getByText("Committed after the first chat unsubscribed.", { exact: true }),
+      ).toHaveCount(0);
+      await selectAgent(page, "First viewed chat");
+      await expect(
+        page.getByText("Committed after the first chat unsubscribed.", { exact: true }),
+      ).toBeVisible();
+      await expect(page.getByText("(end of synthetic stream)", { exact: true })).toBeVisible();
+    } finally {
+      await scenario.cleanup();
+    }
+  });
+
+  test("a hidden retained chat stays current during unsubscribe grace", async ({ page }) => {
+    test.setTimeout(60_000);
+    const subscriptions = observeTimelineSubscriptions(page);
+    const scenario = await seedViewedTimelineScenario();
+    try {
+      await openAgent(page, scenario, scenario.firstAgentId);
+      await selectAgent(page, "Second viewed chat");
+      await subscriptions.waitForSubscribedAgents([scenario.firstAgentId, scenario.secondAgentId]);
+      await commitMessage(
+        scenario,
+        scenario.firstAgentId,
+        "Committed while the first chat is hidden.",
+      );
+      await expect(
+        page.getByText("Committed while the first chat is hidden.", { exact: true }),
+      ).toHaveCount(0);
+      await selectAgent(page, "First viewed chat");
+      await expect(
+        page.getByText("Committed while the first chat is hidden.", { exact: true }),
+      ).toBeVisible();
+      await expect(page.getByText("(end of synthetic stream)", { exact: true })).toBeVisible();
+    } finally {
+      await scenario.cleanup();
+    }
+  });
+
+  test("two visible split chats both stay current", async ({ page }) => {
+    const scenario = await seedViewedTimelineScenario();
+    try {
+      await enableMoveTabShortcut(page);
+      await openAgent(page, scenario, scenario.firstAgentId);
+      await page.getByRole("button", { name: "Split pane right" }).click();
+      await selectAgent(page, "Second viewed chat");
+      await moveActiveTabRight(page);
+      await expect(
+        page.getByRole("button", { name: "First viewed chat", exact: true }),
+      ).toBeVisible();
+      await expect(
+        page.getByRole("button", { name: "Second viewed chat", exact: true }),
+      ).toBeVisible();
+      await expect(page.getByRole("textbox", { name: "Message agent..." })).toHaveCount(2);
+      await commitMessage(scenario, scenario.firstAgentId, "First visible pane update.");
+      await expect(page.getByText("First visible pane update.", { exact: true })).toBeVisible();
+      await expect(
+        page.getByRole("button", { name: "Second viewed chat", exact: true }),
+      ).toBeVisible();
+    } finally {
+      await scenario.cleanup();
+    }
+  });
+
+  test("a visible chat catches up after reconnecting", async ({ page }) => {
+    const gate = await installDaemonWebSocketGate(page);
+    const scenario = await seedViewedTimelineScenario();
+    try {
+      await openAgent(page, scenario, scenario.firstAgentId);
+      await expect(page.getByRole("button", { name: "First viewed chat" })).toHaveAttribute(
+        "aria-selected",
+        "true",
+      );
+      await gate.drop();
+      await expectReconnectingToastVisible(page);
+      await commitMessage(scenario, scenario.firstAgentId, "Committed while the chat reconnects.");
+      await expect(
+        page.getByText("Committed while the chat reconnects.", { exact: true }),
+      ).toHaveCount(0);
+      gate.restore();
+      await expectReconnectingToastGone(page);
+      const recoveredMessage = page.getByText("Committed while the chat reconnects.", {
+        exact: true,
+      });
+      await expect(recoveredMessage).toHaveCount(1);
+      await expect(recoveredMessage).toBeVisible();
+    } finally {
+      gate.restore();
+      await scenario.cleanup();
+    }
+  });
+});
@@ -1,5 +1,6 @@
 import { test, expect } from "./fixtures";
 import { expectComposerVisible, submitMessage } from "./helpers/composer";
+import { delayCreatedAgentInitialTailResponse } from "./helpers/agent-timeline-gate";
 import { delayBrowserAgentCreatedStatus } from "./helpers/new-workspace";
 import { seedWorkspace, type SeedDaemonClient } from "./helpers/seed-client";
 import { waitForWorkspaceTabsVisible } from "./helpers/workspace-tabs";
@@ -43,6 +44,49 @@ async function fetchActiveAgentTitle(
 }

 test.describe("Workspace agent title handoff", () => {
+  test("does not cover the agent pane while the optimistic create becomes authoritative", async ({
+    page,
+  }) => {
+    test.setTimeout(120_000);
+    await page.setViewportSize({ width: 1440, height: 900 });
+
+    const timelineGate = await delayCreatedAgentInitialTailResponse(page);
+    const workspace = await seedWorkspace({ repoPrefix: "workspace-create-handoff-flash-" });
+
+    try {
+      await page.goto(buildHostWorkspaceRoute(getServerId(), workspace.workspaceId));
+      await waitForWorkspaceTabsVisible(page);
+      await page.getByTestId("workspace-new-agent-tab-inline").click();
+      await expectComposerVisible(page);
+
+      const prompt = "Keep the optimistic agent pane visible during handoff";
+      await submitMessage(page, prompt);
+      const agentId = await timelineGate.waitForCreatedAgent();
+      await timelineGate.waitForDelayedResponse();
+
+      await expect(page.getByTestId(`workspace-tab-agent_${agentId}`).first()).toBeVisible({
+        timeout: 15_000,
+      });
+      await expect(page.getByText(prompt, { exact: true }).first()).toBeVisible();
+      await expect(page.getByTestId("agent-history-overlay")).toHaveCount(0);
+
+      const overlayAppeared = page
+        .getByTestId("agent-history-overlay")
+        .waitFor({ state: "attached", timeout: 2_000 })
+        .then(
+          () => true,
+          () => false,
+        );
+      timelineGate.release();
+      await timelineGate.waitForForwardedResponse();
+
+      expect(await overlayAppeared).toBe(false);
+    } finally {
+      timelineGate.release();
+      await workspace.cleanup();
+    }
+  });
+
  test("shows the prompt tab title and replaces it when the daemon title updates", async ({
    page,
  }) => {
@@ -20,7 +20,7 @@ import {
 import { waitForSidebarHydration } from "./helpers/workspace-ui";
 import { getVisibleWorkspaceAgentTabIds } from "./helpers/workspace-tabs";

-const LEGACY_AGENT_ID = "legacy-cwd-only-agent";
+const LEGACY_AGENT_ID = "10000000-0000-4000-8000-000000000001";
 const SERVER_ID = `srv_restart_${randomUUID().replace(/-/g, "").slice(0, 16)}`;

 interface RestartDaemonClient {
@@ -1,5 +1,8 @@
-import { buildHostAgentDetailRoute, buildHostWorkspaceRoute } from "@/utils/host-routes";
-import type { WebSocketRoute } from "@playwright/test";
+import {
+  buildHostAgentDetailRoute,
+  buildHostWorkspaceOpenRoute,
+  buildHostWorkspaceRoute,
+} from "@/utils/host-routes";
 import { expect, test, type Page } from "./fixtures";
 import { gotoAppShell, openSettings } from "./helpers/app";
 import {
@@ -32,10 +35,53 @@ import {
 } from "./helpers/workspace-ui";
 import { clickSettingsBackToWorkspace } from "./helpers/settings";
 import { getServerId } from "./helpers/server-id";
-import { injectDesktopBridge } from "./helpers/desktop-updates";
+import { injectDesktopBridge, waitForDesktopDaemonStartRequest } from "./helpers/desktop-updates";
 import { expectAppRoute } from "./helpers/route-assertions";
+import { installDaemonWebSocketGate } from "./helpers/daemon-websocket-gate";
+import { addOfflineHostAndReload } from "./helpers/hosts";

 const LOADING_WORKSPACE_TEXT_PATTERN = /Loading workspace/i;
+type StartupPresentation = "splash" | "app";
+
+declare global {
+  interface Window {
+    __paseoStartupPresentationTrace?: StartupPresentation[];
+  }
+}
+
+async function observeStartupPresentation(page: Page): Promise<void> {
+  await page.addInitScript(() => {
+    const trace: StartupPresentation[] = [];
+    window.__paseoStartupPresentationTrace = trace;
+
+    document.addEventListener("DOMContentLoaded", () => {
+      const recordPresentation = () => {
+        let presentation: StartupPresentation | null = null;
+        if (document.querySelector('[data-testid="startup-splash"]')) {
+          presentation = "splash";
+        } else if (
+          document.querySelector(
+            '[data-testid="workspace-header-title"], [data-testid="sidebar-settings"]',
+          )
+        ) {
+          presentation = "app";
+        }
+        if (presentation && trace.at(-1) !== presentation) {
+          trace.push(presentation);
+        }
+      };
+      new MutationObserver(recordPresentation).observe(document.documentElement, {
+        childList: true,
+        subtree: true,
+      });
+      recordPresentation();
+    });
+  });
+}
+
+async function getStartupPresentation(page: Page): Promise<StartupPresentation[]> {
+  return page.evaluate(() => window.__paseoStartupPresentationTrace?.slice() ?? []);
+}

 async function expectNoLoadingWorkspacePane(
  page: Page,
@@ -114,64 +160,46 @@ async function expectWorkspaceLocation(
  });
 }

-async function installDaemonWebSocketGate(page: Page) {
-  let acceptingConnections = true;
-  const activeSockets = new Set<WebSocketRoute>();
-
-  await page.routeWebSocket(daemonWsRoutePattern(), (ws) => {
-    if (!acceptingConnections) {
-      void ws.close({ code: 1008, reason: "Blocked by workspace reconnect regression test." });
-      return;
-    }
-
-    activeSockets.add(ws);
-    const server = ws.connectToServer();
-
-    ws.onMessage((message) => {
-      if (!acceptingConnections) {
-        return;
-      }
-      try {
-        server.send(message);
-      } catch {
-        activeSockets.delete(ws);
-      }
-    });
-
-    server.onMessage((message) => {
-      if (!acceptingConnections) {
-        return;
-      }
-      try {
-        ws.send(message);
-      } catch {
-        activeSockets.delete(ws);
-      }
-    });
-  });
-
-  return {
-    async drop(): Promise<void> {
-      acceptingConnections = false;
-      const sockets = Array.from(activeSockets);
-      activeSockets.clear();
-      await Promise.all(
-        sockets.map((ws) =>
-          ws
-            .close({ code: 1008, reason: "Dropped by workspace reconnect regression test." })
-            .catch(() => undefined),
-        ),
-      );
-    },
-    restore(): void {
-      acceptingConnections = true;
-    },
-  };
-}
-
 test.describe("Workspace navigation regression", () => {
  test.describe.configure({ timeout: 240_000 });

+  test("opens a notification's workspace on a different offline host", async ({ page }) => {
+    const target = {
+      serverId: "notification-offline-host",
+      workspaceId: "notification-workspace",
+      agentId: "notification-agent",
+    };
+
+    await gotoAppShell(page);
+    await addOfflineHostAndReload(page, {
+      serverId: target.serverId,
+      label: "Notification Host",
+    });
+    await expect(
+      page.getByTestId("sidebar-settings").filter({ visible: true }).first(),
+    ).toBeVisible({
+      timeout: 30_000,
+    });
+
+    await page.evaluate((data) => {
+      globalThis.dispatchEvent(
+        new CustomEvent("paseo:web-notification-click", {
+          detail: { data: { ...data, reason: "finished" } },
+          cancelable: true,
+        }),
+      );
+    }, target);
+
+    await expectAppRoute(
+      page,
+      buildHostWorkspaceOpenRoute(target.serverId, target.workspaceId, `agent:${target.agentId}`),
+      { timeout: 30_000 },
+    );
+    await expect(page.getByText("Connecting", { exact: true })).toBeVisible();
+    await expect(page.getByText("Notification Host", { exact: true })).toBeVisible();
+    await expect(page.getByText("Add a project", { exact: true })).toHaveCount(0);
+  });
+
  test("keeps one replacement draft after returning from settings and closing the last tab", async ({
    page,
    withWorkspace,
@@ -294,7 +322,9 @@ test.describe("Workspace navigation regression", () => {
    }
  });

-  test("refresh keeps the user on the same workspace route", async ({ page }) => {
+  test("refresh keeps one continuous splash before restoring the workspace route", async ({
+    page,
+  }) => {
    const serverId = getServerId();
    const daemonGate = await installDaemonWebSocketGate(page);
    const workspace = await seedWorkspace({ repoPrefix: "workspace-refresh-route-" });
@@ -309,6 +339,7 @@ test.describe("Workspace navigation regression", () => {
        serverId,
        manageBuiltInDaemon: true,
        hangDaemonStart: true,
+        desktopSettingsDelayMs: 250,
        daemonListen: `127.0.0.1:${getE2EDaemonPort()}`,
      });
      await openWorkspaceThroughApp(page, { serverId, workspace });
@@ -316,14 +347,16 @@ test.describe("Workspace navigation regression", () => {
      await expectWorkspaceTabVisible(page, agent.id);
      await expectWorkspaceLocation(page, { serverId, workspace });

+      await observeStartupPresentation(page);
      await daemonGate.drop();
      await page.reload();
-      await expect(page.getByTestId("startup-splash")).toBeVisible({ timeout: 30_000 });
+      await waitForDesktopDaemonStartRequest(page);
      daemonGate.restore();
      await waitForSidebarHydration(page);

      await expectWorkspaceLocation(page, { serverId, workspace });
      await waitForWorkspaceTabsVisible(page);
+      expect(await getStartupPresentation(page)).toEqual(["splash", "app"]);
    } finally {
      daemonGate.restore();
      await workspace.cleanup();
@@ -429,12 +462,13 @@ test.describe("Workspace navigation regression", () => {
      await expectWorkspaceDeckEntryCount(page, 2);

      await page.evaluate(
-        ({ agentId, serverId: targetServerId }) => {
+        ({ agentId, serverId: targetServerId, workspaceId }) => {
          globalThis.dispatchEvent(
            new CustomEvent("paseo:web-notification-click", {
              detail: {
                data: {
                  serverId: targetServerId,
+                  workspaceId,
                  agentId,
                  reason: "finished",
                },
@@ -443,7 +477,7 @@ test.describe("Workspace navigation regression", () => {
            }),
          );
        },
-        { agentId: secondAgent.id, serverId },
+        { agentId: secondAgent.id, serverId, workspaceId: secondWorkspace.workspaceId },
      );
      await waitForWorkspaceTabsVisible(page);
      await expect(page).toHaveURL(buildHostWorkspaceRoute(serverId, secondWorkspace.workspaceId), {
@@ -1,9 +1,10 @@
 import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
-import { expect, test } from "./fixtures";
+import { expect, test, type Page } from "@playwright/test";
 import { gotoAppShell } from "./helpers/app";
 import { createIdleAgent, expectSessionRowArchived, openSessions } from "./helpers/archive-tab";
-import { restartTestDaemon } from "./helpers/daemon-restart";
+import { buildCreateAgentPreferences, buildSeededHost } from "./helpers/daemon-registry";
+import { startIsolatedHostDaemon, type IsolatedHostDaemon } from "./helpers/isolated-host-daemon";
 import {
  archiveWorkspaceFromDaemon,
  connectNewWorkspaceDaemonClient,
@@ -11,11 +12,12 @@ import {
  openProjectViaDaemon,
 } from "./helpers/new-workspace";
 import { connectSeedClient } from "./helpers/seed-client";
-import { getServerId } from "./helpers/server-id";
 import { createTempGitRepo } from "./helpers/workspace";
 import { waitForSidebarHydration } from "./helpers/workspace-ui";

 test.describe("Worktree restore after daemon restart", () => {
+  const serverId = `srv_worktree_restart_${randomUUID().replaceAll("-", "").slice(0, 12)}`;
+  let daemon: IsolatedHostDaemon;
  let client: Awaited<ReturnType<typeof connectSeedClient>>;
  let worktreeClient: Awaited<ReturnType<typeof connectNewWorkspaceDaemonClient>>;
  let tempRepo: { path: string; cleanup: () => Promise<void> };
@@ -25,8 +27,9 @@ test.describe("Worktree restore after daemon restart", () => {
  test.describe.configure({ retries: 0, timeout: 180_000 });

  test.beforeEach(async () => {
-    client = await connectSeedClient();
-    worktreeClient = await connectNewWorkspaceDaemonClient();
+    daemon = await startIsolatedHostDaemon(serverId);
+    client = await connectSeedClient({ port: daemon.port });
+    worktreeClient = await connectNewWorkspaceDaemonClient({ port: daemon.port });
    tempRepo = await createTempGitRepo("wt-restart-");
  });

@@ -42,13 +45,33 @@ test.describe("Worktree restore after daemon restart", () => {
    await client?.close().catch(() => undefined);
    await worktreeClient?.close().catch(() => undefined);
    await tempRepo?.cleanup().catch(() => undefined);
+    await daemon?.close().catch(() => undefined);
  });

+  async function seedBrowser(page: Page) {
+    const nowIso = new Date().toISOString();
+    await page.addInitScript(
+      ({ host, preferences }) => {
+        localStorage.setItem("@paseo:e2e", "1");
+        localStorage.setItem("@paseo:daemon-registry", JSON.stringify([host]));
+        localStorage.removeItem("@paseo:settings");
+        localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
+      },
+      {
+        host: buildSeededHost({
+          serverId,
+          endpoint: `127.0.0.1:${daemon.port}`,
+          label: "restart daemon",
+          nowIso,
+        }),
+        preferences: buildCreateAgentPreferences(serverId),
+      },
+    );
+  }
+
  test("after archiving a worktree and restarting the daemon, History shows the worktree branch (not main) before any restore", async ({
    page,
  }) => {
-    const serverId = getServerId();
-
    // A paseo worktree is cut on its own branch named after the slug, and the
    // worktree workspace is displayed under the same name. These are the values
    // the History table cells must show after restore — never "main".
@@ -76,14 +99,16 @@ test.describe("Worktree restore after daemon restart", () => {
      .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
      .toBe(false);

-    // Bounce the isolated test daemon on the SAME home and port so it rebuilds
-    // all workspace/agent links from persisted state. Then reconnect both clients.
+    // Restart this spec's daemon on the same home and port so it rebuilds all
+    // workspace/agent links from persisted state without replacing the shared
+    // Playwright daemon owned by global setup.
    await client.close().catch(() => undefined);
    await worktreeClient.close().catch(() => undefined);
-    await restartTestDaemon();
-    client = await connectSeedClient();
-    worktreeClient = await connectNewWorkspaceDaemonClient();
+    await daemon.restart();
+    client = await connectSeedClient({ port: daemon.port });
+    worktreeClient = await connectNewWorkspaceDaemonClient({ port: daemon.port });

+    await seedBrowser(page);
    await gotoAppShell(page);
    await waitForSidebarHydration(page);
    await openSessions(page);
@@ -44,7 +44,10 @@ test.describe("Worktree restore", () => {
    tempRepo = await createTempGitRepo("wt-restore-");
  });

-  async function createArchivedMissingWorktree(prefix: string) {
+  async function createArchivedMissingWorktree(
+    prefix: string,
+    options: { agentCount?: number; keepAgentsArchived?: boolean } = {},
+  ) {
    const project = await openProjectViaDaemon(worktreeClient, tempRepo.path);
    createdProjectIds.add(project.projectKey);
    const worktree = await createWorktreeViaDaemon(worktreeClient, {
@@ -53,11 +56,19 @@ test.describe("Worktree restore", () => {
    });
    createdProjectIds.add(worktree.projectKey);
    createdWorktreeDirectories.add(worktree.workspaceDirectory);
-    const agent = await createIdleAgent(client, {
-      cwd: worktree.workspaceDirectory,
-      workspaceId: worktree.workspaceId,
-      title: `${prefix}-${randomUUID().slice(0, 8)}`,
-    });
+    const agents = await Promise.all(
+      Array.from({ length: options.agentCount ?? 1 }, () =>
+        createIdleAgent(client, {
+          cwd: worktree.workspaceDirectory,
+          workspaceId: worktree.workspaceId,
+          title: `${prefix}-${randomUUID().slice(0, 8)}`,
+        }),
+      ),
+    );
+    const agent = agents[0];
+    if (!agent) {
+      throw new Error("Expected at least one archived-worktree agent");
+    }

    await archiveWorkspaceFromDaemon(worktreeClient, worktree.workspaceDirectory);
    await expect
@@ -67,11 +78,21 @@ test.describe("Worktree restore", () => {
    // Match the remote cloud-race record: workspace archived and absent, while
    // the surviving closed agent record is not agent-archived. Refresh now owns
    // only agent lifecycle, so its expected cwd failure cannot recover the workspace.
-    await client.refreshAgent(agent.id).catch(() => undefined);
-    await expect.poll(() => fetchAgentArchivedAt(client, agent.id), { timeout: 30_000 }).toBeNull();
+    if (options.keepAgentsArchived) {
+      for (const archivedAgent of agents) {
+        await expect
+          .poll(() => fetchAgentArchivedAt(client, archivedAgent.id), { timeout: 30_000 })
+          .not.toBeNull();
+      }
+    } else {
+      await client.refreshAgent(agent.id).catch(() => undefined);
+      await expect
+        .poll(() => fetchAgentArchivedAt(client, agent.id), { timeout: 30_000 })
+        .toBeNull();
+    }
    expect(existsSync(worktree.workspaceDirectory)).toBe(false);

-    return { agent, worktree };
+    return { agent, agents, worktree };
  }

  async function openArchivedWorkspaceFromHistory(page: Page, prefix: string) {
@@ -241,6 +262,54 @@ test.describe("Worktree restore", () => {
    ).toHaveText(switchedBranch, { timeout: 30_000 });
  });

+  test("recovers the selected agent with its workspace and later rescues another archived agent", async ({
+    page,
+  }) => {
+    const { agents, worktree } = await createArchivedMissingWorktree("restore-agents", {
+      agentCount: 2,
+      keepAgentsArchived: true,
+    });
+    const [firstAgent, secondAgent] = agents;
+    if (!firstAgent || !secondAgent) {
+      throw new Error("Expected two archived agents");
+    }
+
+    await gotoAppShell(page);
+    await waitForSidebarHydration(page);
+    await openSessions(page);
+    await page.getByTestId(`agent-row-${getServerId()}-${firstAgent.id}`).click();
+
+    await expect(page.getByText("Workspace archived", { exact: true })).toBeVisible({
+      timeout: 30_000,
+    });
+    await page.getByTestId("workspace-recovery-action").click();
+    await expect
+      .poll(() => existsSync(worktree.workspaceDirectory), { timeout: 30_000 })
+      .toBe(true);
+    await expect(
+      page.getByTestId(`workspace-tab-agent_${firstAgent.id}`).filter({ visible: true }).first(),
+    ).toBeVisible({ timeout: 30_000 });
+    await expect
+      .poll(() => fetchAgentArchivedAt(client, firstAgent.id), { timeout: 30_000 })
+      .toBeNull();
+    await expect(page.getByRole("button", { name: "Unarchive" })).toHaveCount(0, {
+      timeout: 30_000,
+    });
+
+    await openSessions(page);
+    await page.getByTestId(`agent-row-${getServerId()}-${secondAgent.id}`).click();
+    await expect(
+      page.getByTestId(`workspace-tab-agent_${secondAgent.id}`).filter({ visible: true }).first(),
+    ).toBeVisible({ timeout: 30_000 });
+    await expect(page.getByRole("button", { name: "Unarchive" })).toBeVisible({
+      timeout: 30_000,
+    });
+    await page.getByRole("button", { name: "Unarchive" }).click();
+    await expect
+      .poll(() => fetchAgentArchivedAt(client, secondAgent.id), { timeout: 30_000 })
+      .toBeNull();
+  });
+
  test("restore failure stays visible and permits a successful retry", async ({ page }) => {
    const { agent, worktree } = await openArchivedWorkspaceFromHistory(page, "restore-retry");
    const displacedProjectPath = `${tempRepo.path}-temporarily-unavailable`;
@@ -249,7 +318,7 @@ test.describe("Worktree restore", () => {
    try {
      await page.getByTestId("workspace-recovery-action").click();
      await expect(page.getByTestId("workspace-recovery-error")).toHaveText(
-        "The project directory needed to restore this worktree no longer exists.",
+        "The source repository needed to restore this worktree no longer exists.",
      );
      await expect(page.getByTestId("workspace-recovery-action")).toHaveText("Retry");
      expect(existsSync(worktree.workspaceDirectory)).toBe(false);
@@ -25,6 +25,7 @@
      "extends": "production",
      "distribution": "internal",
      "android": {
+        "resourceClass": "large",
        "buildType": "apk",
        "gradleCommand": ":app:assembleRelease -x lint -x lintVitalAnalyzeRelease -x lintVitalRelease -x generateReleaseLintModel -x generateReleaseLintVitalModel"
      }
@@ -1,6 +1,6 @@
 {
  "name": "@getpaseo/app",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.3",
  "private": true,
  "main": "index.ts",
  "scripts": {
@@ -32,6 +32,11 @@
    "build:terminal-webview": "node ./scripts/build-terminal-webview-html.mjs"
  },
  "dependencies": {
+    "@codemirror/commands": "6.10.4",
+    "@codemirror/language": "6.12.4",
+    "@codemirror/search": "6.7.1",
+    "@codemirror/state": "6.7.1",
+    "@codemirror/view": "6.43.6",
    "@dnd-kit/core": "^6.3.1",
    "@dnd-kit/sortable": "^10.0.0",
    "@dnd-kit/utilities": "^3.2.2",
@@ -46,6 +51,7 @@
    "@react-native-masked-view/masked-view": "^0.3.2",
    "@react-native/normalize-colors": "^0.81.5",
    "@react-navigation/native": "^7.1.8",
+    "@replit/codemirror-vim": "6.3.0",
    "@tanstack/react-query": "^5.90.11",
    "@tanstack/react-virtual": "^3.13.21",
    "@xterm/addon-clipboard": "^0.3.0-beta.213",
@@ -16,6 +16,7 @@ import {
  type AddProjectHost,
 } from "./model";
 import {
+  addProjectMethodEmptyText,
  buildAddProjectMethods,
  buildCloneLocationOptions,
  buildManualGithubRepositoryChoices,
@@ -110,6 +111,13 @@ describe("Add Project navigation", () => {
 });

 describe("Add Project options", () => {
+  it("hides every mutating method when the host lacks stable project identity", () => {
+    const outdatedHost = { ...HOST, canAddProject: false };
+
+    expect(buildAddProjectMethods(outdatedHost)).toEqual([]);
+    expect(addProjectMethodEmptyText(outdatedHost)).toBe("Update the host to use Add Project.");
+  });
+
  it("keeps host-upgrade methods discoverable while hiding local-only Browse", () => {
    expect(
      buildAddProjectMethods({
@@ -34,14 +34,13 @@ export function filterAddProjectHosts(hosts: AddProjectHost[], query: string): A
 }

 export function buildAddProjectMethods(host: AddProjectHost): AddProjectMethodOption[] {
+  if (!host.canAddProject) return [];
  const options: AddProjectMethodOption[] = [];
-  if (host.canAddProject) {
-    options.push({
-      id: "directory-search",
-      label: "Search for directory",
-      description: `Find a directory on ${host.label}`,
-    });
-  }
+  options.push({
+    id: "directory-search",
+    label: "Search for directory",
+    description: `Find a directory on ${host.label}`,
+  });
  if (host.canBrowse) {
    options.push({
      id: "browse",
@@ -66,6 +65,12 @@ export function buildAddProjectMethods(host: AddProjectHost): AddProjectMethodOp
  return options;
 }

+export function addProjectMethodEmptyText(host: AddProjectHost | null): string {
+  return host?.canAddProject === false
+    ? "Update the host to use Add Project."
+    : "No matching options";
+}
+
 function githubMethodDescription(host: AddProjectHost): string {
  if (!host.canCloneGithubRepositories) {
    return "Update this host to clone GitHub repositories";
@@ -257,6 +257,35 @@ describe("bottom anchor controller driver", () => {
    expect(harness.scrollToBottom).not.toHaveBeenCalled();
  });

+  it("pauses sticky maintenance while a user scroll owns the viewport", () => {
+    const harness = createDriverHarness({
+      transportBehavior: {
+        verificationDelayFrames: 2,
+        verificationRetryMode: "recheck",
+      },
+    });
+
+    harness.driver.prepareForStickyContentChange();
+    harness.driver.beginUserScroll();
+    harness.driver.handleContentSizeChange({
+      previousContentHeight: 1200,
+      contentHeight: 1400,
+    });
+    harness.context.nearBottom = false;
+    harness.driver.handleScrollNearBottomChange({
+      nextIsNearBottom: false,
+      scrollDelta: 1,
+    });
+    harness.scheduler.flushAll();
+
+    expect(harness.scrollToBottom).toHaveBeenCalledTimes(1);
+    expect(harness.driver.getSnapshot()).toMatchObject({
+      mode: "detached",
+      pendingRequest: null,
+      pendingVerification: null,
+    });
+  });
+
  it("switches back to sticky-bottom for explicit jump-to-bottom", () => {
    const harness = createDriverHarness({
      isNearBottom: false,
@@ -68,6 +68,8 @@ interface BottomAnchorControllerDriver {
  resetForAgent: () => void;
  applyRouteRequest: (request: BottomAnchorRouteRequest | null) => void;
  requestLocalAnchor: (request: BottomAnchorLocalRequest) => void;
+  beginUserScroll: () => void;
+  endUserScroll: () => void;
  detachByUser: () => void;
  handleViewportMetricsChange: (params: {
    previousViewportWidth: number;
@@ -243,6 +245,7 @@ function createBottomAnchorControllerDriver(
  let lastRouteRequestKey: string | null = null;
  let stickyMeasurementRevision = 0;
  let lastVerifiedStickyMeasurementRevision = 0;
+  let isUserScrollActive = false;

  const setBlockedReason = (nextBlockedReason: BottomAnchorBlockedReason | null) => {
    if (blockedReason === nextBlockedReason) {
@@ -481,6 +484,7 @@ function createBottomAnchorControllerDriver(
      cancelPendingAttempt();
      stickyMeasurementRevision = 0;
      lastVerifiedStickyMeasurementRevision = 0;
+      isUserScrollActive = false;
      mode = "sticky-bottom";
      input.onModeChange("sticky-bottom");
    },
@@ -497,6 +501,21 @@ function createBottomAnchorControllerDriver(
    requestLocalAnchor(request) {
      createRequest(request);
    },
+    beginUserScroll() {
+      isUserScrollActive = true;
+      cancelPendingRequest("user_scroll_started");
+    },
+    endUserScroll() {
+      isUserScrollActive = false;
+      if (mode !== "sticky-bottom") {
+        return;
+      }
+      if (input.isNearBottom()) {
+        markStickyMeasurementVerified();
+        return;
+      }
+      this.detachByUser();
+    },
    detachByUser() {
      if (mode === "detached") {
        return;
@@ -511,6 +530,9 @@ function createBottomAnchorControllerDriver(
      ) {
        markStickyMeasurementChanged();
      }
+      if (isUserScrollActive) {
+        return;
+      }
      const shouldRestick = __private__.shouldRestickOnViewportChange({
        mode,
        previousViewportWidth: params.previousViewportWidth,
@@ -529,6 +551,9 @@ function createBottomAnchorControllerDriver(
      if (params.previousContentHeight !== params.contentHeight) {
        markStickyMeasurementChanged();
      }
+      if (isUserScrollActive) {
+        return;
+      }
      const shouldRestick = __private__.shouldRestickOnContentChange({
        mode,
        previousContentHeight: params.previousContentHeight,
@@ -558,6 +583,9 @@ function createBottomAnchorControllerDriver(
        return;
      }
      markStickyMeasurementChanged();
+      if (isUserScrollActive) {
+        return;
+      }
      if (!pendingRequest) {
        pendingVerification = { requestId: null, retries: 0 };
        if (attemptHandle) {
@@ -571,6 +599,12 @@ function createBottomAnchorControllerDriver(
    },
    handleScrollNearBottomChange(params) {
      const { nextIsNearBottom, scrollDelta } = params;
+      if (isUserScrollActive) {
+        if (mode === "sticky-bottom" && !nextIsNearBottom) {
+          this.detachByUser();
+        }
+        return;
+      }
      if (
        nextIsNearBottom &&
        mode === "sticky-bottom" &&
@@ -737,6 +771,12 @@ export function useBottomAnchorController(input: {
    requestLocalAnchor(request: BottomAnchorLocalRequest) {
      driverRef.current?.requestLocalAnchor(request);
    },
+    beginUserScroll() {
+      driverRef.current?.beginUserScroll();
+    },
+    endUserScroll() {
+      driverRef.current?.endUserScroll();
+    },
    detachByUser() {
      driverRef.current?.detachByUser();
    },
@@ -11,6 +11,7 @@ import {
  FlatList,
  ActivityIndicator,
  Keyboard,
+  Platform,
  View,
  type LayoutChangeEvent,
  type ListRenderItemInfo,
@@ -88,6 +89,8 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
    contentMeasuredForKey: null as string | null,
  });
  const scrollOffsetYRef = useRef(0);
+  const isUserScrollActiveRef = useRef(false);
+  const userScrollEndFrameIdRef = useRef<number | null>(null);
  const programmaticScrollEventBudgetRef = useRef(0);
  const [isNativeViewportSettling, setIsNativeViewportSettling] = useState(false);
  const nativeViewportSettlingFrameIdRef = useRef<number | null>(null);
@@ -128,6 +131,13 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
    }
  }, []);

+  const clearPendingUserScrollEnd = useCallback(() => {
+    if (userScrollEndFrameIdRef.current !== null) {
+      cancelAnimationFrame(userScrollEndFrameIdRef.current);
+      userScrollEndFrameIdRef.current = null;
+    }
+  }, []);
+
  const markNativeViewportSettling = useCallback(() => {
    clearNativeViewportSettling();
    setIsNativeViewportSettling(true);
@@ -189,6 +199,12 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
    },
    scrollToBottom,
  });
+  // Android's maintainVisibleContentPosition ignores the list inversion transform and
+  // fights the controller's offset-zero correction while the live header grows.
+  const maintainVisibleContentPosition =
+    Platform.OS === "android" && bottomAnchorController.mode === "sticky-bottom"
+      ? undefined
+      : DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION;

  useEffect(() => {
    streamViewportMetricsRef.current = {
@@ -201,6 +217,8 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
      contentMeasuredForKey: null,
    };
    scrollOffsetYRef.current = 0;
+    isUserScrollActiveRef.current = false;
+    clearPendingUserScrollEnd();
    clearNativeViewportSettling();
    setIsNativeViewportSettling(false);
    historyStartReadyRef.current = false;
@@ -209,8 +227,9 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
    });
    return () => {
      cancelAnimationFrame(frame);
+      clearPendingUserScrollEnd();
    };
-  }, [agentId, clearNativeViewportSettling]);
+  }, [agentId, clearNativeViewportSettling, clearPendingUserScrollEnd]);

  useEffect(() => {
    const keyboardEvents = [
@@ -294,7 +313,11 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
      onNearHistoryStart();
    }

-    if (programmaticScrollEventBudgetRef.current > 0 && contentOffset.y <= 8) {
+    if (
+      !isUserScrollActiveRef.current &&
+      programmaticScrollEventBudgetRef.current > 0 &&
+      contentOffset.y <= 8
+    ) {
      programmaticScrollEventBudgetRef.current -= 1;
    } else {
      programmaticScrollEventBudgetRef.current = 0;
@@ -305,6 +328,31 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
    }
  });

+  const handleScrollBeginDrag = useStableEvent(() => {
+    clearPendingUserScrollEnd();
+    isUserScrollActiveRef.current = true;
+    bottomAnchorController.beginUserScroll();
+  });
+
+  const handleScrollEndDrag = useStableEvent(() => {
+    clearPendingUserScrollEnd();
+    userScrollEndFrameIdRef.current = requestAnimationFrame(() => {
+      userScrollEndFrameIdRef.current = null;
+      isUserScrollActiveRef.current = false;
+      bottomAnchorController.endUserScroll();
+    });
+  });
+
+  const handleMomentumScrollBegin = useStableEvent(() => {
+    clearPendingUserScrollEnd();
+  });
+
+  const handleMomentumScrollEnd = useStableEvent(() => {
+    clearPendingUserScrollEnd();
+    isUserScrollActiveRef.current = false;
+    bottomAnchorController.endUserScroll();
+  });
+
  const handleListLayout = useStableEvent((event: LayoutChangeEvent) => {
    const previousViewportWidth = streamViewportMetricsRef.current.viewportWidth;
    const previousViewportHeight = streamViewportMetricsRef.current.viewportHeight;
@@ -412,9 +460,13 @@ function NativeStreamViewport(props: StreamRenderInput & { strategy: StreamStrat
      style={listStyle}
      onLayout={handleListLayout}
      onScroll={handleScroll}
+      onScrollBeginDrag={handleScrollBeginDrag}
+      onScrollEndDrag={handleScrollEndDrag}
+      onMomentumScrollBegin={handleMomentumScrollBegin}
+      onMomentumScrollEnd={handleMomentumScrollEnd}
      scrollEventThrottle={16}
      onContentSizeChange={handleContentSizeChange}
-      maintainVisibleContentPosition={DEFAULT_MAINTAIN_VISIBLE_CONTENT_POSITION}
+      maintainVisibleContentPosition={maintainVisibleContentPosition}
      initialNumToRender={40}
      maxToRenderPerBatch={40}
      updateCellsBatchingPeriod={0}
@@ -99,7 +99,7 @@ import {
  useWorkspaceAttachmentsStore,
 } from "@/attachments/workspace-attachments-store";
 import type { WorkspaceComposerAttachment } from "@/attachments/types";
-import type { WorkspaceDraftTabSetup, WorkspaceTabTarget } from "@/stores/workspace-tabs-store";
+import type { WorkspaceDraftTabSetup, WorkspaceTabTarget } from "@/workspace-tabs/model";
 import { toErrorMessage } from "@/utils/error-messages";
 import { useWorkspaceDraftSubmissionStore } from "@/stores/workspace-draft-submission-store";

@@ -1234,7 +1234,9 @@ function PermissionActionButton({
  onPress,
 }: PermissionActionButtonProps) {
  const handlePress = useCallback(() => onPress(action), [onPress, action]);
-  const optionTextStyle = isPrimary ? optionTextPrimaryStyle : permissionStyles.optionText;
+  const optionTextStyle = isPrimary
+    ? [permissionStyles.optionText, permissionStyles.optionTextPrimary]
+    : permissionStyles.optionText;
  const colorMapping = isPrimary ? primaryColorMapping : mutedColorMapping;
  return (
    <Pressable testID={testID} style={pressableStyle} onPress={handlePress} disabled={isResponding}>
@@ -1622,8 +1624,6 @@ const permissionStyles = StyleSheet.create((theme) => ({
  },
 }));

-const optionTextPrimaryStyle = [permissionStyles.optionText, permissionStyles.optionTextPrimary];
-
 interface StreamItemWrapperProps {
  gapBelow: number;
  children: ReactNode;
@@ -21,7 +21,8 @@ import { GestureDetector, GestureHandlerRootView } from "react-native-gesture-ha
 import { KeyboardProvider } from "react-native-keyboard-controller";
 import { SafeAreaProvider } from "react-native-safe-area-context";
 import { StyleSheet, UnistylesRuntime, useUnistyles } from "react-native-unistyles";
-import { CommandCenter } from "@/components/command-center";
+import { CommandCenter, CommandCenterRootActions } from "@/command-center/command-center";
+import { CommandCenterProvider } from "@/command-center/provider";
 import { AddProjectFlowHost } from "@/components/add-project-flow-host";
 import { WorktreeSetupCalloutSource } from "@/components/worktree-setup-callout-source";
 import { DownloadToast } from "@/components/download-toast";
@@ -59,13 +60,13 @@ import {
  resolveStartupBlocker,
  resolveStartupNavigationReady,
  shouldRunStartupGiveUpTimer,
-  startDaemonIfGateAllows,
  startHostRuntimeBootstrap,
  type StartupBlocker,
 } from "@/navigation/host-runtime-bootstrap";
 import { registerWorkspaceRouteNavigationRef } from "@/navigation/workspace-route-navigation";
 import { ThemedStack } from "@/navigation/themed-stack";
 import { shouldUseDesktopDaemon } from "@/desktop/daemon/desktop-daemon";
+import { AgentNavigationListener } from "@/desktop/agent-navigation";
 import { listenToDesktopEvent } from "@/desktop/electron/events";
 import { updateDesktopWindowControls } from "@/desktop/electron/window";
 import { getDesktopHost } from "@/desktop/host";
@@ -146,9 +147,10 @@ function PushNotificationRouter() {
  const openNotification = useStableEvent((data: Record<string, unknown> | undefined) => {
    const target = resolveNotificationTarget(data);
    const serverId = target.serverId;
+    const workspaceId = target.workspaceId;
    const agentId = target.agentId;
-    if (serverId && agentId) {
-      navigateToAgent({ serverId, agentId, pin: true });
+    if (serverId && workspaceId && agentId) {
+      navigateToAgent({ serverId, workspaceId, agentId, pin: true });
      return;
    }

@@ -336,7 +338,6 @@ function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {
      store,
      daemonStartService,
      shouldStartDaemon: shouldStartBuiltInDaemon,
-      onGateError: (message) => daemonStartService.recordError(message),
    });
  }, []);

@@ -375,11 +376,7 @@ function HostRuntimeBootstrapProvider({ children }: { children: ReactNode }) {

  const retry = useCallback(() => {
    const daemonStartService = getDaemonStartService({ store: getHostRuntimeStore() });
-    startDaemonIfGateAllows({
-      daemonStartService,
-      shouldStartDaemon: shouldStartBuiltInDaemon,
-      onGateError: (message) => daemonStartService.recordError(message),
-    });
+    void daemonStartService.startIfEnabled({ shouldStart: shouldStartBuiltInDaemon });
  }, []);

  const splashError =
@@ -553,6 +550,7 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
      <RosettaCalloutSource />
      <UpdateCalloutSource />
      <WorktreeSetupCalloutSource />
+      <CommandCenterRootActions />
      <CommandCenter />
      <AddProjectFlowHost />
      <HostChooserModal />
@@ -570,7 +568,7 @@ function AppContainer({ children, chromeEnabled: chromeEnabledOverride }: AppCon
    surface
  );

-  return content;
+  return <CommandCenterProvider>{content}</CommandCenterProvider>;
 }

 function SidebarChrome({
@@ -912,6 +910,7 @@ function AppShell() {
    <MobilePanelsProvider>
      <HorizontalScrollProvider>
        <OpenProjectListener />
+        <AgentNavigationListener />
        <AppWithSidebar>
          <WorkspaceRouteNavigationBridge />
          <RootStack />
@@ -1,10 +1,13 @@
-import { useEffect, useRef } from "react";
+import { useCallback, useEffect, useMemo, useRef } from "react";
 import { useLocalSearchParams, useRouter, type Href } from "expo-router";
 import { HostRouteBootstrapBoundary } from "@/components/host-route-bootstrap-boundary";
+import { useFetchQuery } from "@/data/query";
+import { resolveAgentRoute, type AgentRouteLookup } from "@/navigation/agent-route-resolution";
+import { AgentRouteResolutionView } from "@/navigation/agent-route-resolution-view";
 import { useSessionStore } from "@/stores/session-store";
-import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-runtime";
-import { buildHostRootRoute } from "@/utils/host-routes";
-import { normalizeWorkspaceOpaqueId } from "@/utils/workspace-identity";
+import { getHostRuntimeStore, useHostRuntimeSnapshot, useHosts } from "@/runtime/host-runtime";
+import { buildHostRootRoute, buildSettingsHostRoute } from "@/utils/host-routes";
+import { toErrorMessage } from "@/utils/error-messages";
 import { navigateToAgent } from "@/utils/navigate-to-agent";

 export default function HostAgentReadyRoute() {
@@ -21,97 +24,128 @@ function HostAgentReadyRouteContent() {
    serverId?: string;
    agentId?: string;
  }>();
-  const redirectedRef = useRef(false);
+  const handledNavigationRef = useRef<string | null>(null);
  const serverId = typeof params.serverId === "string" ? params.serverId : "";
  const agentId = typeof params.agentId === "string" ? params.agentId : "";
-  const client = useHostRuntimeClient(serverId);
-  const isConnected = useHostRuntimeIsConnected(serverId);
+  const hosts = useHosts();
+  const runtimeSnapshot = useHostRuntimeSnapshot(serverId);
+  const client = runtimeSnapshot?.client ?? null;
+  const connectionStatus = runtimeSnapshot?.connectionStatus ?? "connecting";
+  const hostName = hosts.find((host) => host.serverId === serverId)?.label ?? serverId;
  const agentWorkspaceId = useSessionStore((state) => {
    if (!serverId || !agentId) {
      return null;
    }
    return state.sessions[serverId]?.agents?.get(agentId)?.workspaceId ?? null;
  });
-  const hasHydratedWorkspaces = useSessionStore((state) =>
-    serverId ? (state.sessions[serverId]?.hasHydratedWorkspaces ?? false) : false,
+  const shouldLookupAgent = Boolean(
+    serverId && agentId && client && connectionStatus === "online" && !agentWorkspaceId,
  );
-  const resolvedWorkspaceId = normalizeWorkspaceOpaqueId(agentWorkspaceId);
+  const lookupQuery = useFetchQuery({
+    queryKey: ["agentRouteResolution", serverId, agentId, runtimeSnapshot?.clientGeneration ?? 0],
+    queryFn: async () => {
+      if (!client) {
+        throw new Error("Target host client is unavailable");
+      }
+      const result = await client.fetchAgent({ agentId });
+      return result?.agent?.workspaceId ?? null;
+    },
+    enabled: shouldLookupAgent,
+    retry: false,
+    dataShape: "value",
+    staleTimeMs: 0,
+  });
+  const lookup = useMemo<AgentRouteLookup>(() => {
+    if (!shouldLookupAgent) {
+      return { kind: "idle" };
+    }
+    if (lookupQuery.isFetching) {
+      return { kind: "fetching" };
+    }
+    if (lookupQuery.isError) {
+      return { kind: "failed", error: toErrorMessage(lookupQuery.error) };
+    }
+    if (lookupQuery.isSuccess) {
+      return { kind: "found", workspaceId: lookupQuery.data };
+    }
+    return { kind: "fetching" };
+  }, [
+    lookupQuery.data,
+    lookupQuery.error,
+    lookupQuery.isError,
+    lookupQuery.isFetching,
+    lookupQuery.isSuccess,
+    shouldLookupAgent,
+  ]);
+  const resolution = resolveAgentRoute({
+    serverId,
+    agentId,
+    cachedWorkspaceId: agentWorkspaceId,
+    connectionStatus,
+    lookup,
+  });

  useEffect(() => {
-    if (redirectedRef.current) {
-      return;
+    let navigationKey: string | null = null;
+    if (resolution.kind === "invalid") {
+      navigationKey = "invalid";
+    } else if (resolution.kind === "resolved") {
+      navigationKey = `workspace:${resolution.workspaceId}`;
+    } else if (resolution.kind === "notFound") {
+      navigationKey = "not-found";
    }
-    if (!serverId || !agentId) {
-      redirectedRef.current = true;
-      router.replace("/" as Href);
+    if (!navigationKey || handledNavigationRef.current === navigationKey) {
      return;
    }
+    handledNavigationRef.current = navigationKey;

-    if (resolvedWorkspaceId) {
-      redirectedRef.current = true;
-      navigateToAgent({
-        serverId,
-        agentId,
-      });
+    if (resolution.kind === "resolved") {
+      navigateToAgent({ serverId, agentId, workspaceId: resolution.workspaceId });
+      return;
    }
-  }, [agentId, resolvedWorkspaceId, router, serverId]);
+    router.replace(resolution.kind === "invalid" ? ("/" as Href) : buildHostRootRoute(serverId));
+  }, [agentId, resolution, router, serverId]);

-  useEffect(() => {
-    if (redirectedRef.current) {
+  const handleRetry = useCallback(() => {
+    if (resolution.kind === "lookupError") {
+      void lookupQuery.refetch();
      return;
    }
-    if (!serverId || !agentId) {
+    if (serverId) {
+      void getHostRuntimeStore().runProbeCycleNow(serverId);
+    }
+  }, [lookupQuery, resolution.kind, serverId]);
+  const handleManageHost = useCallback(() => {
+    if (serverId) {
+      router.push(buildSettingsHostRoute(serverId));
+    }
+  }, [router, serverId]);
+  const handleBack = useCallback(() => {
+    if (router.canGoBack()) {
+      router.back();
      return;
    }
-    if (agentWorkspaceId && !hasHydratedWorkspaces) {
-      return;
-    }
-    if (!client || !isConnected) {
-      redirectedRef.current = true;
-      router.replace(buildHostRootRoute(serverId));
-    }
-  }, [agentWorkspaceId, agentId, client, hasHydratedWorkspaces, isConnected, router, serverId]);
+    router.replace(serverId ? buildHostRootRoute(serverId) : ("/" as Href));
+  }, [router, serverId]);

-  useEffect(() => {
-    if (redirectedRef.current) {
-      return;
-    }
-    if (!serverId || !agentId || !client || !isConnected) {
-      return;
-    }
-
-    let cancelled = false;
-    void client
-      .fetchAgent({ agentId })
-      .then((result) => {
-        if (cancelled || redirectedRef.current) {
-          return;
-        }
-        const workspaceId = normalizeWorkspaceOpaqueId(result?.agent?.workspaceId);
-        redirectedRef.current = true;
-        if (workspaceId) {
-          navigateToAgent({
-            serverId,
-            agentId,
-            workspaceId,
-          });
-          return;
-        }
-        router.replace(buildHostRootRoute(serverId));
-        return;
-      })
-      .catch(() => {
-        if (cancelled || redirectedRef.current) {
-          return;
-        }
-        redirectedRef.current = true;
-        router.replace(buildHostRootRoute(serverId));
-      });
-
-    return () => {
-      cancelled = true;
-    };
-  }, [agentId, client, isConnected, router, serverId]);
+  if (
+    resolution.kind === "waitingForHost" ||
+    resolution.kind === "fetchingAgent" ||
+    resolution.kind === "lookupError"
+  ) {
+    // Agent URLs intentionally omit workspaceId. Keep this route mounted while the target host
+    // reconnects, then resolve the workspace from the authoritative agent record.
+    return (
+      <AgentRouteResolutionView
+        resolution={resolution}
+        hostName={hostName}
+        lastHostError={runtimeSnapshot?.lastError ?? null}
+        onRetry={handleRetry}
+        onManageHost={handleManageHost}
+        onBack={handleBack}
+      />
+    );
+  }

  return null;
 }
@@ -9,7 +9,7 @@ import {
  useActiveWorkspaceSelection,
 } from "@/stores/navigation-active-workspace-store";
 import { useHasHydratedWorkspaces, useWorkspaceExists } from "@/stores/session-store-hooks";
-import type { WorkspaceTabTarget } from "@/stores/workspace-tabs-store";
+import type { WorkspaceTabTarget } from "@/workspace-tabs/model";
 import { WorkspaceScreen } from "@/screens/workspace/workspace-screen";
 import { useWorkspaceLayoutStoreHydrated } from "@/stores/workspace-layout-store";
 import {
@@ -110,7 +110,9 @@ function HostWorkspaceRouteContent() {
  const openValue = getParamValue(globalParams.open);
  const hasHydratedWorkspaces = useHasHydratedWorkspaces(serverId);
  const workspaceExists = useWorkspaceExists(serverId, workspaceId);
-  const isAgentOpenIntent = parseWorkspaceOpenIntent(openValue)?.kind === "agent";
+  const openIntent = useMemo(() => parseWorkspaceOpenIntent(openValue), [openValue]);
+  const recoveryAgentId = openIntent?.kind === "agent" ? openIntent.agentId : null;
+  const isAgentOpenIntent = recoveryAgentId !== null;
  const isOpenIntentWaitingForWorkspace = Boolean(
    isAgentOpenIntent && (!hasHydratedWorkspaces || !workspaceExists),
  );
@@ -147,7 +149,6 @@ function HostWorkspaceRouteContent() {
    }
    consumedIntentRef.current = consumptionKey;

-    const openIntent = parseWorkspaceOpenIntent(openValue);
    if (openIntent) {
      prepareWorkspaceTab({
        serverId,
@@ -171,6 +172,7 @@ function HostWorkspaceRouteContent() {
    hasHydratedWorkspaceLayoutStore,
    isOpenIntentWaitingForWorkspace,
    navigation,
+    openIntent,
    openValue,
    rootNavigationState?.key,
    serverId,
@@ -185,10 +187,16 @@ function HostWorkspaceRouteContent() {
    return null;
  }

-  return <WorkspaceDeck recoveryRequested={isAgentOpenIntent} />;
+  return <WorkspaceDeck recoveryRequested={isAgentOpenIntent} recoveryAgentId={recoveryAgentId} />;
 }

-function WorkspaceDeck({ recoveryRequested }: { recoveryRequested: boolean }) {
+function WorkspaceDeck({
+  recoveryRequested,
+  recoveryAgentId,
+}: {
+  recoveryRequested: boolean;
+  recoveryAgentId: string | null;
+}) {
  const activeSelection = useActiveWorkspaceSelection();
  const [mountedSelections, setMountedSelections] = useState<ActiveWorkspaceSelection[]>(() =>
    activeSelection ? [activeSelection] : [],
@@ -234,6 +242,7 @@ function WorkspaceDeck({ recoveryRequested }: { recoveryRequested: boolean }) {
            selection={selection}
            activeSelection={activeSelection}
            recoveryRequested={recoveryRequested}
+            recoveryAgentId={recoveryAgentId}
            onUnmountInactive={unmountWorkspaceSelection}
          />
        );
@@ -246,11 +255,13 @@ function WorkspaceDeckEntry({
  selection,
  activeSelection,
  recoveryRequested,
+  recoveryAgentId,
  onUnmountInactive,
 }: {
  selection: ActiveWorkspaceSelection;
  activeSelection: ActiveWorkspaceSelection;
  recoveryRequested: boolean;
+  recoveryAgentId: string | null;
  onUnmountInactive: (selection: ActiveWorkspaceSelection) => void;
 }) {
  const isActive = areWorkspaceSelectionsEqual(selection, activeSelection);
@@ -282,6 +293,7 @@ function WorkspaceDeckEntry({
        workspaceId={selection.workspaceId}
        isRouteFocused={isActive}
        recoveryRequested={isActive && recoveryRequested}
+        recoveryAgentId={isActive ? recoveryAgentId : null}
      />
    </RetainedPanel>
  );
@@ -257,10 +257,10 @@ export default function PairScanScreen() {
            />
            <View style={styles.overlay} pointerEvents="none">
              <View style={styles.scanFrame}>
-                <View style={CORNER_TL_STYLE} />
-                <View style={CORNER_TR_STYLE} />
-                <View style={CORNER_BL_STYLE} />
-                <View style={CORNER_BR_STYLE} />
+                <View style={[styles.corner, styles.cornerTL]} />
+                <View style={[styles.corner, styles.cornerTR]} />
+                <View style={[styles.corner, styles.cornerBL]} />
+                <View style={[styles.corner, styles.cornerBR]} />
              </View>
              {isPairing ? <Text style={helperTextStyle}>{t("pairing.scan.pairing")}</Text> : null}
            </View>
@@ -272,7 +272,3 @@ export default function PairScanScreen() {
 }

 const BARCODE_SCANNER_SETTINGS: BarcodeSettings = { barcodeTypes: ["qr"] };
-const CORNER_TL_STYLE = [styles.corner, styles.cornerTL];
-const CORNER_TR_STYLE = [styles.corner, styles.cornerTR];
-const CORNER_BL_STYLE = [styles.corner, styles.cornerBL];
-const CORNER_BR_STYLE = [styles.corner, styles.cornerBR];
@@ -92,9 +92,20 @@ export interface ChatHistoryContextAttachment {

 export const NEW_WORKSPACE_PICKER_ATTACHMENT_OWNER = "new-workspace-picker";

+export type WorkspaceFileSelection =
+  | { kind: "whole_file" }
+  | { kind: "line_range"; startLine: number; endLine: number };
+
+export interface WorkspaceFileComposerAttachment {
+  kind: "workspace_file";
+  path: string;
+  selection: WorkspaceFileSelection;
+}
+
 export type UserComposerAttachment =
  | { kind: "image"; metadata: AttachmentMetadata }
  | { kind: "file"; attachment: UploadedFileAttachment }
+  | WorkspaceFileComposerAttachment
  | { kind: "forge_issue"; item: ForgeSearchItem }
  | { kind: "forge_change_request"; item: ForgeSearchItem }
  // COMPAT(githubAttachmentKinds): added in v0.1.106, remove after 2026-12-28 once daemon floor >= v0.1.106
@@ -0,0 +1,9 @@
+import type { RefCallback } from "react";
+import type { View } from "react-native";
+import type { WorkspaceFileDragSourceInput } from "./workspace-file-drag-source.types";
+
+export function useWorkspaceFileDragSource(
+  _input: WorkspaceFileDragSourceInput,
+): RefCallback<View> | undefined {
+  return undefined;
+}
@@ -0,0 +1,54 @@
+import { useCallback, useEffect, useState, type RefCallback } from "react";
+import type { View } from "react-native";
+import { createWorkspaceFileAttachment } from "./workspace-file";
+import { serializeWorkspaceFileDragPayload, WORKSPACE_FILE_DRAG_MIME } from "./workspace-file-drag";
+import type { WorkspaceFileDragSourceInput } from "./workspace-file-drag-source.types";
+
+export function useWorkspaceFileDragSource({
+  enabled,
+  disabled = false,
+  serverId,
+  workspaceId,
+  path,
+  selection,
+}: WorkspaceFileDragSourceInput): RefCallback<View> {
+  const [element, setElement] = useState<HTMLElement | null>(null);
+  const dragSourceRef = useCallback((node: View | null) => {
+    setElement(node as unknown as HTMLElement | null);
+  }, []);
+
+  useEffect(() => {
+    if (!element || !enabled || disabled || !serverId || !workspaceId) {
+      if (element) {
+        element.draggable = false;
+      }
+      return;
+    }
+
+    const sourceServerId = serverId;
+    const sourceWorkspaceId = workspaceId;
+    element.draggable = true;
+    function handleDragStart(event: DragEvent) {
+      if (!event.dataTransfer) {
+        return;
+      }
+      event.dataTransfer.effectAllowed = "copy";
+      event.dataTransfer.setData(
+        WORKSPACE_FILE_DRAG_MIME,
+        serializeWorkspaceFileDragPayload({
+          version: 1,
+          serverId: sourceServerId,
+          workspaceId: sourceWorkspaceId,
+          attachment: createWorkspaceFileAttachment({ path, selection }),
+        }),
+      );
+    }
+    element.addEventListener("dragstart", handleDragStart);
+    return () => {
+      element.draggable = false;
+      element.removeEventListener("dragstart", handleDragStart);
+    };
+  }, [disabled, element, enabled, path, selection, serverId, workspaceId]);
+
+  return dragSourceRef;
+}
@@ -0,0 +1,10 @@
+import type { WorkspaceFileSelection } from "./types";
+
+export interface WorkspaceFileDragSourceInput {
+  enabled: boolean;
+  disabled?: boolean;
+  serverId?: string;
+  workspaceId: string | null | undefined;
+  path: string;
+  selection?: WorkspaceFileSelection;
+}
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { createWorkspaceFileAttachment } from "./workspace-file";
+import {
+  parseWorkspaceFileDragPayload,
+  resolveWorkspaceFileDrop,
+  serializeWorkspaceFileDragPayload,
+  type WorkspaceFileDragPayload,
+} from "./workspace-file-drag";
+
+function payload(): WorkspaceFileDragPayload {
+  return {
+    version: 1,
+    serverId: "server-1",
+    workspaceId: "workspace-1",
+    attachment: createWorkspaceFileAttachment({
+      path: "src/app.ts",
+      selection: { kind: "line_range", startLine: 12, endLine: 24 },
+    }),
+  };
+}
+
+describe("workspace file drag payload", () => {
+  it("round-trips workspace identity and future line selections", () => {
+    expect(parseWorkspaceFileDragPayload(serializeWorkspaceFileDragPayload(payload()))).toEqual(
+      payload(),
+    );
+  });
+
+  it("rejects malformed and invalid payloads", () => {
+    expect(parseWorkspaceFileDragPayload("not json")).toBeNull();
+    expect(
+      parseWorkspaceFileDragPayload(
+        JSON.stringify({
+          ...payload(),
+          attachment: {
+            kind: "workspace_file",
+            path: "src/app.ts",
+            selection: { kind: "line_range", startLine: 24, endLine: 12 },
+          },
+        }),
+      ),
+    ).toBeNull();
+  });
+
+  it("accepts drops only within the originating server and workspace", () => {
+    const dragged = payload();
+    expect(
+      resolveWorkspaceFileDrop({
+        payload: dragged,
+        serverId: "server-1",
+        workspaceId: "workspace-1",
+      }),
+    ).toEqual(dragged.attachment);
+    expect(
+      resolveWorkspaceFileDrop({
+        payload: dragged,
+        serverId: "server-1",
+        workspaceId: "workspace-2",
+      }),
+    ).toBeNull();
+  });
+});
@@ -0,0 +1,55 @@
+import type { WorkspaceFileComposerAttachment } from "./types";
+import { isWorkspaceFileComposerAttachment } from "./workspace-file";
+
+export const WORKSPACE_FILE_DRAG_MIME = "application/x-paseo-workspace-file+json";
+
+export interface WorkspaceFileDragPayload {
+  version: 1;
+  serverId: string;
+  workspaceId: string;
+  attachment: WorkspaceFileComposerAttachment;
+}
+
+export function serializeWorkspaceFileDragPayload(payload: WorkspaceFileDragPayload): string {
+  return JSON.stringify(payload);
+}
+
+export function parseWorkspaceFileDragPayload(serialized: string): WorkspaceFileDragPayload | null {
+  let value: unknown;
+  try {
+    value = JSON.parse(serialized);
+  } catch {
+    return null;
+  }
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    record.version !== 1 ||
+    typeof record.serverId !== "string" ||
+    record.serverId.length === 0 ||
+    typeof record.workspaceId !== "string" ||
+    record.workspaceId.length === 0 ||
+    !isWorkspaceFileComposerAttachment(record.attachment)
+  ) {
+    return null;
+  }
+  return {
+    version: 1,
+    serverId: record.serverId,
+    workspaceId: record.workspaceId,
+    attachment: record.attachment,
+  };
+}
+
+export function resolveWorkspaceFileDrop(input: {
+  payload: WorkspaceFileDragPayload;
+  serverId: string;
+  workspaceId: string;
+}): WorkspaceFileComposerAttachment | null {
+  return input.payload.serverId === input.serverId &&
+    input.payload.workspaceId === input.workspaceId
+    ? input.payload.attachment
+    : null;
+}
@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import type { UserComposerAttachment } from "@/attachments/types";
+import {
+  appendWorkspaceFileAttachment,
+  createWorkspaceFileAttachment,
+  getWorkspaceFileAttachmentKey,
+  getWorkspaceFileAttachmentSubtitle,
+  workspaceFileAttachmentToAgentAttachment,
+} from "./workspace-file";
+import { splitComposerAttachmentsForSubmit } from "@/composer/attachments/submit";
+
+describe("workspace file attachments", () => {
+  it("models whole files and line ranges as distinct selections", () => {
+    const wholeFile = createWorkspaceFileAttachment({ path: "src/app.ts" });
+    const lineRange = createWorkspaceFileAttachment({
+      path: "src/app.ts",
+      selection: { kind: "line_range", startLine: 12, endLine: 24 },
+    });
+
+    expect(wholeFile).toEqual({
+      kind: "workspace_file",
+      path: "src/app.ts",
+      selection: { kind: "whole_file" },
+    });
+    expect(getWorkspaceFileAttachmentKey(wholeFile)).not.toBe(
+      getWorkspaceFileAttachmentKey(lineRange),
+    );
+    expect(getWorkspaceFileAttachmentSubtitle(wholeFile)).toBe("src/app.ts");
+    expect(getWorkspaceFileAttachmentSubtitle(lineRange)).toBe("src/app.ts · 12-24");
+  });
+
+  it("deduplicates only identical paths and selections", () => {
+    const image = {
+      kind: "image" as const,
+      metadata: {
+        id: "image-1",
+        mimeType: "image/png",
+        storageType: "web-indexeddb" as const,
+        storageKey: "image-1",
+        createdAt: 1,
+      },
+    };
+    const wholeFile = createWorkspaceFileAttachment({ path: "src/app.ts" });
+    const range = createWorkspaceFileAttachment({
+      path: "src/app.ts",
+      selection: { kind: "line_range", startLine: 1, endLine: 5 },
+    });
+    const current: UserComposerAttachment[] = [image, wholeFile];
+
+    expect(appendWorkspaceFileAttachment(current, wholeFile)).toBe(current);
+    expect(appendWorkspaceFileAttachment(current, range)).toEqual([image, wholeFile, range]);
+  });
+
+  it("submits a path reference without uploading or inserting prompt text", () => {
+    const attachment = createWorkspaceFileAttachment({
+      path: "src/app.ts",
+      selection: { kind: "line_range", startLine: 12, endLine: 24 },
+    });
+
+    expect(workspaceFileAttachmentToAgentAttachment(attachment)).toEqual({
+      type: "text",
+      mimeType: "text/plain",
+      title: "app.ts",
+      text: "Workspace file: src/app.ts\nLines: 12-24",
+    });
+    expect(splitComposerAttachmentsForSubmit([attachment])).toEqual({
+      images: [],
+      attachments: [workspaceFileAttachmentToAgentAttachment(attachment)],
+    });
+  });
+});
@@ -0,0 +1,106 @@
+import type { AgentAttachment } from "@getpaseo/protocol/messages";
+import type {
+  UserComposerAttachment,
+  WorkspaceFileComposerAttachment,
+  WorkspaceFileSelection,
+} from "./types";
+
+interface CreateWorkspaceFileAttachmentInput {
+  path: string;
+  selection?: WorkspaceFileSelection;
+}
+
+function normalizePath(path: string): string {
+  return path.trim().replace(/^\.\//, "");
+}
+
+export function isWorkspaceFileComposerAttachment(
+  value: unknown,
+): value is WorkspaceFileComposerAttachment {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value as Record<string, unknown>;
+  if (
+    record.kind !== "workspace_file" ||
+    typeof record.path !== "string" ||
+    record.path.trim().length === 0
+  ) {
+    return false;
+  }
+  const selection = record.selection;
+  if (!selection || typeof selection !== "object") {
+    return false;
+  }
+  const { kind, startLine, endLine } = selection as Record<string, unknown>;
+  if (kind === "whole_file") {
+    return true;
+  }
+  return (
+    kind === "line_range" &&
+    typeof startLine === "number" &&
+    Number.isInteger(startLine) &&
+    typeof endLine === "number" &&
+    Number.isInteger(endLine) &&
+    startLine > 0 &&
+    endLine >= startLine
+  );
+}
+
+export function createWorkspaceFileAttachment({
+  path,
+  selection = { kind: "whole_file" },
+}: CreateWorkspaceFileAttachmentInput): WorkspaceFileComposerAttachment {
+  return {
+    kind: "workspace_file",
+    path: normalizePath(path),
+    selection,
+  };
+}
+
+export function getWorkspaceFileAttachmentKey(attachment: WorkspaceFileComposerAttachment): string {
+  const selection = attachment.selection;
+  const selectionKey =
+    selection.kind === "whole_file"
+      ? selection.kind
+      : `${selection.kind}:${selection.startLine}-${selection.endLine}`;
+  return `${normalizePath(attachment.path)}:${selectionKey}`;
+}
+
+export function appendWorkspaceFileAttachment(
+  current: UserComposerAttachment[],
+  attachment: WorkspaceFileComposerAttachment,
+): UserComposerAttachment[] {
+  const attachmentKey = getWorkspaceFileAttachmentKey(attachment);
+  const alreadyAttached = current.some(
+    (candidate) =>
+      candidate.kind === "workspace_file" &&
+      getWorkspaceFileAttachmentKey(candidate) === attachmentKey,
+  );
+  return alreadyAttached ? current : [...current, attachment];
+}
+
+export function workspaceFileAttachmentToAgentAttachment(
+  attachment: WorkspaceFileComposerAttachment,
+): Extract<AgentAttachment, { type: "text" }> {
+  const fileName = attachment.path.split("/").pop() ?? attachment.path;
+  const lines =
+    attachment.selection.kind === "line_range"
+      ? `\nLines: ${attachment.selection.startLine}-${attachment.selection.endLine}`
+      : "";
+  return {
+    type: "text",
+    mimeType: "text/plain",
+    title: fileName,
+    text: `Workspace file: ${attachment.path}${lines}`,
+  };
+}
+
+export function getWorkspaceFileAttachmentSubtitle(
+  attachment: WorkspaceFileComposerAttachment,
+): string {
+  if (attachment.selection.kind === "whole_file") {
+    return attachment.path;
+  }
+  return `${attachment.path} · ${attachment.selection.startLine}-${attachment.selection.endLine}`;
+}
@@ -4,10 +4,8 @@ import { createJSONStorage, type StateStorage } from "zustand/middleware";
 import { mountBrowserAutomationHandler } from "./handler";
 import type { DesktopHostBridge } from "@/desktop/host";
 import { useBrowserStore } from "@/stores/browser-store";
-import {
-  buildWorkspaceTabPersistenceKey,
-  useWorkspaceLayoutStore,
-} from "@/stores/workspace-layout-store";
+import { useWorkspaceLayoutStore } from "@/stores/workspace-layout-store";
+import { buildWorkspaceTabPersistenceKey } from "@/workspace-tabs/model";

 type BrowserAutomationExecuteRequest = Extract<
  SessionOutboundMessage,
@@ -6,11 +6,8 @@ import {
  resizeResidentBrowserWebview,
 } from "@/components/browser-webview-resident";
 import { createWorkspaceBrowser, getBrowserRecord, useBrowserStore } from "@/stores/browser-store";
-import {
-  buildWorkspaceTabPersistenceKey,
-  collectAllTabs,
-  useWorkspaceLayoutStore,
-} from "@/stores/workspace-layout-store";
+import { collectAllTabs, useWorkspaceLayoutStore } from "@/stores/workspace-layout-store";
+import { buildWorkspaceTabPersistenceKey } from "@/workspace-tabs/model";

 type BrowserAutomationExecuteRequest = Extract<
  SessionOutboundMessage,
@@ -1,5 +1,5 @@
 import type { Agent } from "@/stores/session-store";
-import type { WorkspaceDraftTabSetup } from "@/stores/workspace-tabs-store";
+import type { WorkspaceDraftTabSetup } from "@/workspace-tabs/model";

 export type ClientSlashCommandKind = "archive-agent" | "replace-agent-with-draft";
 export type ClientSlashCommandExecution = "immediate" | "insert";
@@ -0,0 +1,792 @@
+import {
+  FlatList,
+  Modal,
+  Pressable,
+  Text,
+  TextInput,
+  View,
+  type ListRenderItemInfo,
+  type PressableStateCallbackType,
+} from "react-native";
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { router, type Href } from "expo-router";
+import { useTranslation } from "react-i18next";
+import { Check, ChevronRight, Folder, Home, Plus, Settings } from "lucide-react-native";
+import { StyleSheet, withUnistyles } from "react-native-unistyles";
+import {
+  BottomSheetBackdrop,
+  BottomSheetFlatList,
+  BottomSheetTextInput,
+  type BottomSheetFlatListMethods,
+} from "@gorhom/bottom-sheet";
+import { AgentStatusDot } from "@/components/agent-status-dot";
+import { Shortcut } from "@/components/ui/shortcut";
+import {
+  IsolatedBottomSheetModal,
+  useIsolatedBottomSheetVisibility,
+} from "@/components/ui/isolated-bottom-sheet-modal";
+import { getIsElectronRuntime, useIsCompactFormFactor } from "@/constants/layout";
+import { isNative, isWeb } from "@/constants/platform";
+import { useAggregatedAgents, type AggregatedAgent } from "@/hooks/use-aggregated-agents";
+import { useKeyboardShortcutOverrides } from "@/hooks/use-keyboard-shortcut-overrides";
+import { useOpenAddProject } from "@/hooks/use-open-add-project";
+import { useProjects } from "@/hooks/use-projects";
+import { useHosts } from "@/runtime/host-runtime";
+import { useKeyboardShortcutsStore } from "@/stores/keyboard-shortcuts-store";
+import { navigateToWorkspace } from "@/stores/navigation-active-workspace-store";
+import { getBindingIdForAction, getDefaultKeysForAction } from "@/keyboard/keyboard-shortcuts";
+import { chordStringToShortcutKeys } from "@/keyboard/shortcut-string";
+import { keyboardActionDispatcher } from "@/keyboard/keyboard-action-dispatcher";
+import {
+  clearCommandCenterFocusRestoreElement,
+  takeCommandCenterFocusRestoreElement,
+} from "@/utils/command-center-focus-restore";
+import { focusWithRetries } from "@/utils/web-focus";
+import { buildOpenProjectRoute, buildSettingsRoute } from "@/utils/host-routes";
+import { navigateToAgent } from "@/utils/navigate-to-agent";
+import { formatTimeAgo } from "@/utils/time";
+import { shortenPath } from "@/utils/shorten-path";
+import { getShortcutOs } from "@/utils/shortcut-platform";
+import type { ShortcutKey } from "@/utils/format-shortcut";
+import type { CommandCenterContribution, CommandCenterIconProps } from "./contributions";
+import { useCommandCenterActions, useCommandCenterContributions } from "./provider";
+import {
+  buildContributionSections,
+  moveActiveResultId,
+  preserveActiveResultId,
+  projectCommandCenterRows,
+  type CommandCenterAgentResult,
+  type CommandCenterListRow,
+  type CommandCenterResult,
+  type CommandCenterResultSection,
+  type CommandCenterWorkspaceResult,
+} from "./results";
+
+const ThemedBottomSheetTextInput = withUnistyles(BottomSheetTextInput, (theme) => ({
+  placeholderTextColor: theme.colors.foregroundMuted,
+}));
+const ThemedTextInput = withUnistyles(TextInput, (theme) => ({
+  placeholderTextColor: theme.colors.foregroundMuted,
+}));
+const ThemedFolder = withUnistyles(Folder, (theme) => ({ color: theme.colors.foregroundMuted }));
+const ThemedCheck = withUnistyles(Check, (theme) => ({ color: theme.colors.foreground }));
+const ThemedChevronRight = withUnistyles(ChevronRight, (theme) => ({
+  color: theme.colors.foregroundMuted,
+}));
+const ThemedPlus = withUnistyles(Plus, (theme) => ({ color: theme.colors.foregroundMuted }));
+const ThemedSettings = withUnistyles(Settings, (theme) => ({
+  color: theme.colors.foregroundMuted,
+}));
+const ThemedHome = withUnistyles(Home, (theme) => ({ color: theme.colors.foregroundMuted }));
+const COMMAND_CENTER_SNAP_POINTS = ["60%", "90%"];
+const KEYBOARD_SHOULD_PERSIST_TAPS = "always" as const;
+
+function PlusIcon({ size }: CommandCenterIconProps) {
+  return <ThemedPlus size={size} strokeWidth={2.4} />;
+}
+
+function SettingsIcon({ size }: CommandCenterIconProps) {
+  return <ThemedSettings size={size} strokeWidth={2.2} />;
+}
+
+function HomeIcon({ size }: CommandCenterIconProps) {
+  return <ThemedHome size={size} strokeWidth={2.2} />;
+}
+
+function resolveActionShortcutKeys(
+  actionId: string | undefined,
+  overrides: Record<string, string>,
+): ShortcutKey[][] | undefined {
+  if (!actionId) return undefined;
+  const platform = {
+    isMac: getShortcutOs() === "mac",
+    isDesktop: getIsElectronRuntime(),
+  };
+  const bindingId = getBindingIdForAction(actionId, platform);
+  if (!bindingId) return undefined;
+  const override = overrides[bindingId];
+  if (override) return chordStringToShortcutKeys(override);
+  const defaultKeys = getDefaultKeysForAction(actionId, platform);
+  return defaultKeys ? [defaultKeys] : undefined;
+}
+
+export function CommandCenterRootActions() {
+  const { t } = useTranslation();
+  const { overrides } = useKeyboardShortcutOverrides();
+  const openAddProject = useOpenAddProject();
+  const settingsRoute = useMemo<Href>(() => buildSettingsRoute(), []);
+  const homeRoute = useMemo<Href>(() => buildOpenProjectRoute(), []);
+  const actions = useMemo<CommandCenterContribution[]>(
+    () => [
+      {
+        id: "new-agent",
+        group: "actions",
+        groupRank: 0,
+        rank: 0,
+        keywords: ["open", "project", "folder", "workspace", "repo"],
+        visibility: "always",
+        run: () => {
+          clearCommandCenterFocusRestoreElement();
+          openAddProject();
+        },
+        presentation: {
+          kind: "action",
+          title: t("shell.commandCenter.addProject"),
+          sectionTitle: t("shell.commandCenter.actions"),
+          icon: PlusIcon,
+          shortcutKeys: resolveActionShortcutKeys("new-agent", overrides),
+        },
+      },
+      {
+        id: "home",
+        group: "actions",
+        groupRank: 0,
+        rank: 1,
+        keywords: ["home", "start", "import", "session", "pair", "device", "providers"],
+        visibility: "always",
+        run: () => {
+          clearCommandCenterFocusRestoreElement();
+          router.push(homeRoute);
+        },
+        presentation: {
+          kind: "action",
+          title: t("shell.commandCenter.home"),
+          sectionTitle: t("shell.commandCenter.actions"),
+          icon: HomeIcon,
+        },
+      },
+      {
+        id: "settings",
+        group: "actions",
+        groupRank: 0,
+        rank: 2,
+        keywords: ["settings", "preferences", "config", "configuration"],
+        visibility: "always",
+        run: () => {
+          clearCommandCenterFocusRestoreElement();
+          router.push(settingsRoute);
+        },
+        presentation: {
+          kind: "action",
+          title: t("sidebar.actions.settings"),
+          sectionTitle: t("shell.commandCenter.actions"),
+          icon: SettingsIcon,
+        },
+      },
+    ],
+    [homeRoute, openAddProject, overrides, settingsRoute, t],
+  );
+
+  useCommandCenterActions({ sourceId: "root", enabled: true, actions });
+  return null;
+}
+
+function sortAgents(left: AggregatedAgent, right: AggregatedAgent): number {
+  const leftNeedsInput = (left.pendingPermissionCount ?? 0) > 0 ? 1 : 0;
+  const rightNeedsInput = (right.pendingPermissionCount ?? 0) > 0 ? 1 : 0;
+  if (leftNeedsInput !== rightNeedsInput) return rightNeedsInput - leftNeedsInput;
+  const leftAttention = left.requiresAttention ? 1 : 0;
+  const rightAttention = right.requiresAttention ? 1 : 0;
+  if (leftAttention !== rightAttention) return rightAttention - leftAttention;
+  const leftRunning = left.status === "running" ? 1 : 0;
+  const rightRunning = right.status === "running" ? 1 : 0;
+  if (leftRunning !== rightRunning) return rightRunning - leftRunning;
+  return right.lastActivityAt.getTime() - left.lastActivityAt.getTime();
+}
+
+function matchesQuery(searchText: string, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  return !normalized || searchText.includes(normalized);
+}
+
+function useBuiltInSections(open: boolean, query: string): CommandCenterResultSection[] {
+  const { t } = useTranslation();
+  const { agents } = useAggregatedAgents();
+  const { projects } = useProjects({ enabled: open });
+  const showAgentHost = useHosts().length > 1;
+
+  return useMemo(() => {
+    if (!open) return [];
+    const allWorkspaces: CommandCenterWorkspaceResult[] = [];
+    for (const project of projects) {
+      for (const host of project.hosts) {
+        for (const workspace of host.workspaces) {
+          if (workspace.archivingAt) continue;
+          const title = workspace.title ?? workspace.name;
+          const subtitle = workspace.currentBranch
+            ? `${host.serverName} · ${workspace.currentBranch}`
+            : host.serverName;
+          const searchText = `${title} ${subtitle}`.toLowerCase();
+          allWorkspaces.push({
+            kind: "workspace",
+            id: `workspace:${host.serverId}:${workspace.id}`,
+            title,
+            subtitle,
+            searchText,
+            run: () => {
+              clearCommandCenterFocusRestoreElement();
+              navigateToWorkspace({ serverId: host.serverId, workspaceId: workspace.id });
+            },
+          });
+        }
+      }
+    }
+    allWorkspaces.sort((left, right) => {
+      const titleDelta = left.title.localeCompare(right.title, undefined, {
+        numeric: true,
+        sensitivity: "base",
+      });
+      return titleDelta || left.subtitle.localeCompare(right.subtitle);
+    });
+    const workspaceTitleByKey = new Map(
+      allWorkspaces.map((workspace) => [workspace.id.slice("workspace:".length), workspace.title]),
+    );
+    const workspaces = allWorkspaces.filter((workspace) =>
+      matchesQuery(workspace.searchText, query),
+    );
+    const agentResults = agents
+      .map<CommandCenterAgentResult>((agent) => {
+        const title = agent.title || t("shell.commandCenter.newAgent");
+        const workspaceTitle = agent.workspaceId
+          ? workspaceTitleByKey.get(`${agent.serverId}:${agent.workspaceId}`)
+          : undefined;
+        const location = workspaceTitle ?? shortenPath(agent.cwd);
+        const subtitle = [
+          showAgentHost ? agent.serverLabel : null,
+          location,
+          formatTimeAgo(agent.lastActivityAt),
+        ]
+          .filter((part): part is string => Boolean(part))
+          .join(" · ");
+        return {
+          kind: "agent",
+          id: `agent:${agent.serverId}:${agent.id}`,
+          agent,
+          title,
+          subtitle,
+          searchText: `${title} ${subtitle} ${agent.cwd}`.toLowerCase(),
+          run: () => {
+            clearCommandCenterFocusRestoreElement();
+            navigateToAgent({ serverId: agent.serverId, agentId: agent.id });
+          },
+        };
+      })
+      .filter((agent) => matchesQuery(agent.searchText, query))
+      .sort((left, right) => sortAgents(left.agent, right.agent));
+    return [
+      {
+        id: "workspaces",
+        rank: 2,
+        title: t("shell.commandCenter.workspaces"),
+        results: workspaces,
+      },
+      { id: "agents", rank: 3, title: t("shell.commandCenter.agents"), results: agentResults },
+    ];
+  }, [agents, open, projects, query, showAgentHost, t]);
+}
+
+interface CommandCenterState {
+  open: boolean;
+  query: string;
+  setQuery(query: string): void;
+  activeId: string | null;
+  rows: readonly CommandCenterListRow[];
+  results: readonly CommandCenterResult[];
+  rowIndexByResultId: ReadonlyMap<string, number>;
+  offsets: readonly number[];
+  inputRef: React.RefObject<TextInput | null>;
+  close(): void;
+  select(result: CommandCenterResult): void;
+  key(key: string): boolean;
+}
+
+function useCommandCenterState(): CommandCenterState {
+  const open = useKeyboardShortcutsStore((state) => state.commandCenterOpen);
+  const setOpen = useKeyboardShortcutsStore((state) => state.setCommandCenterOpen);
+  const snapshot = useCommandCenterContributions();
+  const inputRef = useRef<TextInput>(null);
+  const previousOpenRef = useRef(open);
+  const [query, setQuery] = useState("");
+  const [activeId, setActiveId] = useState<string | null>(null);
+  const builtInSections = useBuiltInSections(open, query);
+  const contributionSections = useMemo(
+    () => buildContributionSections(snapshot.contributions, query),
+    [query, snapshot.contributions],
+  );
+  const projection = useMemo(
+    () => projectCommandCenterRows([...contributionSections, ...builtInSections]),
+    [builtInSections, contributionSections],
+  );
+  const resolvedActiveId = preserveActiveResultId(activeId, projection.selectableResults);
+
+  const close = useCallback(() => setOpen(false), [setOpen]);
+  const select = useCallback(
+    (result: CommandCenterResult) => {
+      setOpen(false);
+      void result.run();
+    },
+    [setOpen],
+  );
+  const key = useCallback(
+    (pressed: string): boolean => {
+      if (!open) return false;
+      const results = projection.selectableResults;
+      if (pressed === "Escape") {
+        close();
+        return true;
+      }
+      if (pressed === "Enter") {
+        const selected = results.find((result) => result.id === resolvedActiveId);
+        if (!selected) return false;
+        select(selected);
+        return true;
+      }
+      if (pressed !== "ArrowDown" && pressed !== "ArrowUp") return false;
+      if (results.length === 0) return false;
+      const direction = pressed === "ArrowDown" ? "next" : "previous";
+      setActiveId(moveActiveResultId(resolvedActiveId, results, direction));
+      return true;
+    },
+    [close, open, projection.selectableResults, resolvedActiveId, select],
+  );
+
+  useEffect(() => {
+    const wasOpen = previousOpenRef.current;
+    previousOpenRef.current = open;
+    if (open) {
+      const timer = setTimeout(() => inputRef.current?.focus(), 0);
+      return () => clearTimeout(timer);
+    }
+    setQuery("");
+    setActiveId(null);
+    if (!wasOpen) return;
+    const element = takeCommandCenterFocusRestoreElement();
+    if (!element) return;
+    const cancel = focusWithRetries({
+      focus: () => element.focus(),
+      isFocused: () => typeof document !== "undefined" && document.activeElement === element,
+      onTimeout: () =>
+        keyboardActionDispatcher.dispatch({ id: "message-input.focus", scope: "message-input" }),
+    });
+    return cancel;
+  }, [open]);
+
+  useEffect(() => {
+    if (!open || !isWeb) return;
+    const listener = (event: KeyboardEvent) => {
+      if (key(event.key)) event.preventDefault();
+    };
+    window.addEventListener("keydown", listener, true);
+    return () => window.removeEventListener("keydown", listener, true);
+  }, [key, open]);
+
+  return {
+    open,
+    query,
+    setQuery,
+    activeId: resolvedActiveId,
+    rows: projection.rows,
+    results: projection.selectableResults,
+    rowIndexByResultId: projection.rowIndexByResultId,
+    offsets: projection.offsets,
+    inputRef,
+    close,
+    select,
+    key,
+  };
+}
+
+interface ResultRowProps {
+  result: CommandCenterResult;
+  active: boolean;
+  onSelect(result: CommandCenterResult): void;
+}
+
+const ResultRow = memo(function ResultRow({ result, active, onSelect }: ResultRowProps) {
+  const press = useCallback(() => onSelect(result), [onSelect, result]);
+  const style = useCallback(
+    ({ hovered, pressed }: PressableStateCallbackType & { hovered?: boolean }) => [
+      styles.row,
+      (result.kind === "agent" ||
+        result.kind === "workspace" ||
+        (result.kind === "contribution" &&
+          result.contribution.presentation.kind === "action" &&
+          Boolean(result.contribution.presentation.subtitle))) &&
+        styles.tallRow,
+      (Boolean(hovered) || pressed || active) && styles.activeRow,
+    ],
+    [active, result],
+  );
+  return (
+    <Pressable style={style} onPress={press}>
+      <ResultContent result={result} />
+    </Pressable>
+  );
+});
+
+function ResultContent({ result }: { result: CommandCenterResult }) {
+  if (result.kind === "agent") {
+    const agent = result.agent;
+    return (
+      <View style={styles.rowContent} testID={`command-center-agent-${agent.serverId}:${agent.id}`}>
+        <View style={styles.rowMain}>
+          <View style={styles.iconSlot}>
+            <AgentStatusDot
+              status={agent.status}
+              requiresAttention={agent.requiresAttention}
+              showInactive
+            />
+          </View>
+          <View style={styles.textContent}>
+            <Text style={styles.title} numberOfLines={1}>
+              {result.title}
+            </Text>
+            <Text style={styles.subtitle} numberOfLines={1} testID="command-center-agent-subtitle">
+              {result.subtitle}
+            </Text>
+          </View>
+        </View>
+      </View>
+    );
+  }
+  if (result.kind === "workspace") {
+    const key = result.id.slice("workspace:".length);
+    return (
+      <View style={styles.rowContent} testID={`command-center-workspace-${key}`}>
+        <View style={styles.rowMain}>
+          <View style={styles.iconSlot}>
+            <ThemedFolder size={16} strokeWidth={2.2} />
+          </View>
+          <View style={styles.textContent}>
+            <Text style={styles.title} numberOfLines={1}>
+              {result.title}
+            </Text>
+            <Text style={styles.subtitle} numberOfLines={1}>
+              {result.subtitle}
+            </Text>
+          </View>
+        </View>
+      </View>
+    );
+  }
+  const presentation = result.contribution.presentation;
+  const Icon = presentation.icon;
+  if (presentation.kind === "action") {
+    return (
+      <View style={styles.rowContent}>
+        <View style={styles.rowMain}>
+          {Icon ? (
+            <View style={styles.iconSlot}>
+              <Icon size={16} />
+            </View>
+          ) : null}
+          <View style={styles.textContent}>
+            <Text style={styles.title} numberOfLines={1}>
+              {presentation.title}
+            </Text>
+            {presentation.subtitle ? (
+              <Text style={styles.subtitle}>{presentation.subtitle}</Text>
+            ) : null}
+          </View>
+        </View>
+        {presentation.shortcutKeys ? (
+          <Shortcut chord={presentation.shortcutKeys} style={styles.rowShortcut} />
+        ) : null}
+      </View>
+    );
+  }
+  return (
+    <View style={styles.rowContent} testID={presentation.testId}>
+      <View style={styles.rowMain}>
+        {Icon ? (
+          <View style={styles.iconSlot}>
+            <Icon size={16} />
+          </View>
+        ) : null}
+        <View style={styles.breadcrumb}>
+          {presentation.path.map((part, index) => (
+            <View
+              key={presentation.path.slice(0, index + 1).join("\u0000")}
+              style={styles.breadcrumbPart}
+            >
+              {index > 0 ? <ThemedChevronRight size={13} strokeWidth={2} /> : null}
+              <Text
+                style={
+                  index === presentation.path.length - 1 ? styles.title : styles.breadcrumbGroup
+                }
+                numberOfLines={1}
+              >
+                {part}
+              </Text>
+            </View>
+          ))}
+        </View>
+      </View>
+      {presentation.selected ? (
+        <View style={styles.iconSlot}>
+          <ThemedCheck size={16} strokeWidth={2.2} />
+        </View>
+      ) : null}
+    </View>
+  );
+}
+
+function SectionRow({ row }: { row: Extract<CommandCenterListRow, { kind: "section" }> }) {
+  let sizeStyle = styles.dividerSection;
+  if (row.title && row.divider) sizeStyle = styles.dividedSection;
+  if (row.title && !row.divider) sizeStyle = styles.titledSection;
+  return (
+    <View style={sizeStyle}>
+      {row.divider ? <View style={styles.sectionDivider} /> : null}
+      {row.title ? <Text style={styles.sectionLabel}>{row.title}</Text> : null}
+    </View>
+  );
+}
+
+export function CommandCenter() {
+  const { t } = useTranslation();
+  const state = useCommandCenterState();
+  const isCompact = useIsCompactFormFactor();
+  const showBottomSheet = isCompact && isNative;
+  const listRef = useRef<FlatList<CommandCenterListRow>>(null);
+  const bottomSheetListRef = useRef<BottomSheetFlatListMethods>(null);
+  const bottomSheetInputRef = useRef<React.ElementRef<typeof BottomSheetTextInput>>(null);
+  const { sheetRef, handleSheetChange, handleSheetDismiss } = useIsolatedBottomSheetVisibility({
+    visible: state.open,
+    isEnabled: showBottomSheet,
+    onClose: state.close,
+  });
+
+  useEffect(() => {
+    if (!state.open || !state.activeId) return;
+    const index = state.rowIndexByResultId.get(state.activeId);
+    if (index === undefined) return;
+    const ref = showBottomSheet ? bottomSheetListRef.current : listRef.current;
+    ref?.scrollToIndex({ index, animated: true, viewPosition: 0.5 });
+  }, [showBottomSheet, state.activeId, state.open, state.rowIndexByResultId]);
+  useEffect(() => {
+    if (!showBottomSheet || !state.open) return;
+    const timer = setTimeout(() => bottomSheetInputRef.current?.focus(), 300);
+    return () => clearTimeout(timer);
+  }, [showBottomSheet, state.open]);
+
+  const renderItem = useCallback(
+    ({ item }: ListRenderItemInfo<CommandCenterListRow>) =>
+      item.kind === "section" ? (
+        <SectionRow row={item} />
+      ) : (
+        <ResultRow
+          result={item.result}
+          active={item.result.id === state.activeId}
+          onSelect={state.select}
+        />
+      ),
+    [state.activeId, state.select],
+  );
+  const getItemLayout = useCallback(
+    (_data: ArrayLike<CommandCenterListRow> | null | undefined, index: number) => ({
+      index,
+      length: state.rows[index].height,
+      offset: state.offsets[index],
+    }),
+    [state.offsets, state.rows],
+  );
+  const keyExtractor = useCallback((row: CommandCenterListRow) => row.key, []);
+  const empty = useMemo(
+    () => <Text style={styles.emptyText}>{t("shell.commandCenter.noMatches")}</Text>,
+    [t],
+  );
+  const commonListProps = {
+    data: state.rows,
+    renderItem,
+    keyExtractor,
+    getItemLayout,
+    ListEmptyComponent: empty,
+    keyboardShouldPersistTaps: KEYBOARD_SHOULD_PERSIST_TAPS,
+    showsVerticalScrollIndicator: false,
+    initialNumToRender: 12,
+    maxToRenderPerBatch: 10,
+    windowSize: 5,
+  };
+  const keyPress = useCallback(
+    ({ nativeEvent: { key } }: { nativeEvent: { key: string } }) => state.key(key),
+    [state],
+  );
+  const submit = useCallback(() => state.key("Enter"), [state]);
+  const backdrop = useCallback(
+    (props: React.ComponentProps<typeof BottomSheetBackdrop>) => (
+      <BottomSheetBackdrop {...props} disappearsOnIndex={-1} appearsOnIndex={0} opacity={0.45} />
+    ),
+    [],
+  );
+
+  if (showBottomSheet) {
+    return (
+      <IsolatedBottomSheetModal
+        ref={sheetRef}
+        snapPoints={COMMAND_CENTER_SNAP_POINTS}
+        index={0}
+        enableDynamicSizing={false}
+        onChange={handleSheetChange}
+        onDismiss={handleSheetDismiss}
+        backdropComponent={backdrop}
+        enablePanDownToClose
+        backgroundStyle={styles.sheetBackground}
+        handleIndicatorStyle={styles.sheetHandle}
+        keyboardBehavior="extend"
+        keyboardBlurBehavior="restore"
+        accessible={false}
+      >
+        <View style={styles.bottomSheetHeader}>
+          <ThemedBottomSheetTextInput
+            testID="command-center-input"
+            ref={bottomSheetInputRef}
+            value={state.query}
+            onChangeText={state.setQuery}
+            onKeyPress={keyPress}
+            onSubmitEditing={submit}
+            placeholder={t("shell.commandCenter.placeholder")}
+            style={styles.input}
+            autoCapitalize="none"
+            autoCorrect={false}
+            autoFocus
+          />
+        </View>
+        <BottomSheetFlatList ref={bottomSheetListRef} {...commonListProps} />
+      </IsolatedBottomSheetModal>
+    );
+  }
+  if (!state.open) return null;
+  return (
+    <Modal visible transparent animationType="fade" onRequestClose={state.close}>
+      <View style={styles.overlay}>
+        <Pressable style={styles.backdrop} onPress={state.close} />
+        <View testID="command-center-panel" style={styles.panel}>
+          <View style={styles.header}>
+            <ThemedTextInput
+              testID="command-center-input"
+              ref={state.inputRef}
+              value={state.query}
+              onChangeText={state.setQuery}
+              placeholder={t("shell.commandCenter.placeholder")}
+              style={styles.input}
+              autoCapitalize="none"
+              autoCorrect={false}
+              autoFocus
+            />
+          </View>
+          <FlatList ref={listRef} style={styles.results} {...commonListProps} />
+        </View>
+      </View>
+    </Modal>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  overlay: {
+    flex: 1,
+    justifyContent: "flex-start",
+    alignItems: "center",
+    paddingTop: theme.spacing[12],
+  },
+  backdrop: { ...StyleSheet.absoluteFillObject, backgroundColor: "rgba(0, 0, 0, 0.5)" },
+  panel: {
+    width: 640,
+    maxWidth: "92%",
+    maxHeight: "80%",
+    borderWidth: 1,
+    borderColor: theme.colors.border,
+    borderRadius: theme.borderRadius.lg,
+    overflow: "hidden",
+    backgroundColor: theme.colors.surface0,
+    ...theme.shadow.lg,
+  },
+  header: {
+    paddingHorizontal: theme.spacing[4],
+    paddingVertical: theme.spacing[3],
+    borderBottomWidth: 1,
+    borderBottomColor: theme.colors.border,
+  },
+  bottomSheetHeader: {
+    paddingHorizontal: theme.spacing[4],
+    paddingVertical: theme.spacing[3],
+    borderBottomWidth: 1,
+    borderBottomColor: theme.colors.border,
+  },
+  input: {
+    fontSize: theme.fontSize.base,
+    paddingVertical: theme.spacing[1],
+    color: theme.colors.foreground,
+    outlineWidth: 0,
+  },
+  results: { flexGrow: 0 },
+  sectionLabel: {
+    paddingHorizontal: theme.spacing[4],
+    paddingBottom: theme.spacing[2],
+    fontSize: theme.fontSize.xs,
+    color: theme.colors.foregroundMuted,
+  },
+  sectionDivider: {
+    height: 1,
+    marginTop: theme.spacing[2],
+    marginBottom: theme.spacing[2],
+    backgroundColor: theme.colors.border,
+  },
+  row: { height: 36, paddingHorizontal: theme.spacing[4], paddingVertical: theme.spacing[2] },
+  tallRow: { height: 56 },
+  activeRow: { backgroundColor: theme.colors.surface1 },
+  rowContent: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: theme.spacing[3],
+  },
+  rowMain: {
+    flex: 1,
+    minWidth: 0,
+    flexDirection: "row",
+    alignItems: "flex-start",
+    gap: theme.spacing[3],
+  },
+  textContent: { flex: 1, minWidth: 0 },
+  title: {
+    color: theme.colors.foreground,
+    fontSize: theme.fontSize.sm,
+    lineHeight: 20,
+    flexShrink: 1,
+  },
+  subtitle: { color: theme.colors.foregroundMuted, fontSize: theme.fontSize.xs, lineHeight: 18 },
+  iconSlot: { width: 16, height: 20, alignItems: "center", justifyContent: "center" },
+  rowShortcut: { flexShrink: 0 },
+  breadcrumb: {
+    flex: 1,
+    minWidth: 0,
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.spacing[1],
+  },
+  breadcrumbPart: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: theme.spacing[1],
+    flexShrink: 1,
+  },
+  breadcrumbGroup: {
+    color: theme.colors.foregroundMuted,
+    fontSize: theme.fontSize.sm,
+    lineHeight: 20,
+    flexShrink: 0,
+  },
+  emptyText: {
+    paddingHorizontal: theme.spacing[4],
+    paddingVertical: theme.spacing[6],
+    textAlign: "center",
+    color: theme.colors.foregroundMuted,
+    fontSize: theme.fontSize.sm,
+  },
+  sheetBackground: { backgroundColor: theme.colors.surface0 },
+  sheetHandle: { backgroundColor: theme.colors.palette.zinc[600] },
+  titledSection: { height: 32, justifyContent: "flex-end" },
+  dividedSection: { height: 49, justifyContent: "flex-end" },
+  dividerSection: { height: 17, justifyContent: "flex-end" },
+}));
@@ -0,0 +1,53 @@
+import type { ComponentType } from "react";
+import type { ShortcutKey } from "@/utils/format-shortcut";
+
+export interface CommandCenterIconProps {
+  size: number;
+}
+
+export type CommandCenterIcon = ComponentType<CommandCenterIconProps>;
+
+interface CommandCenterContributionBase {
+  id: string;
+  group: string;
+  groupRank: number;
+  rank: number;
+  keywords: readonly string[];
+  visibility: "always" | "query";
+  run(): void | Promise<void>;
+}
+
+export type CommandCenterContribution =
+  | (CommandCenterContributionBase & {
+      presentation: {
+        kind: "action";
+        title: string;
+        subtitle?: string;
+        sectionTitle?: string;
+        icon?: CommandCenterIcon;
+        shortcutKeys?: ShortcutKey[][];
+      };
+    })
+  | (CommandCenterContributionBase & {
+      presentation: {
+        kind: "choice";
+        path: readonly [string, ...string[]];
+        icon?: CommandCenterIcon;
+        selected: boolean;
+        testId?: string;
+      };
+    });
+
+export interface CommandCenterContributionSnapshot {
+  contributions: readonly CommandCenterContribution[];
+}
+
+export interface CommandCenterRegistrationOwner {
+  sourceId: string;
+  token: symbol;
+}
+
+export interface CommandCenterRegistration {
+  owner: CommandCenterRegistrationOwner;
+  contributions: readonly CommandCenterContribution[];
+}
@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
+import { buildModelChoiceContributions } from "./model-contributions";
+
+function TestIcon() {
+  return null;
+}
+
+function provider(input: {
+  id: string;
+  label: string;
+  state: "models" | "error";
+}): ProviderSelectorProvider {
+  if (input.state === "error") {
+    return {
+      id: input.id,
+      label: input.label,
+      modelSelection: { kind: "error", message: "Unavailable" },
+    };
+  }
+  return {
+    id: input.id,
+    label: input.label,
+    modelSelection: {
+      kind: "models",
+      rows: [
+        {
+          favoriteKey: `${input.id}:model`,
+          provider: input.id,
+          providerLabel: input.label,
+          modelId: "model",
+          modelLabel: `${input.label} model`,
+          description: undefined,
+        },
+      ],
+    },
+  };
+}
+
+describe("Command Center model choices", () => {
+  it("publishes selectable providers and executes the draft owner's command", () => {
+    const selections: string[] = [];
+    const choices = buildModelChoiceContributions({
+      serverId: "host",
+      providers: [
+        provider({ id: "claude", label: "Claude", state: "models" }),
+        provider({ id: "codex", label: "Codex", state: "models" }),
+      ],
+      selectedProvider: "codex",
+      selectedModelId: "model",
+      groupLabel: "Model",
+      searchKeywords: "model switch",
+      getIcon: () => TestIcon,
+      select: (selectedProvider, modelId) => selections.push(`${selectedProvider}:${modelId}`),
+    });
+
+    expect(
+      choices.map((choice) => ({
+        id: choice.id,
+        selected: choice.presentation.kind === "choice" ? choice.presentation.selected : false,
+      })),
+    ).toEqual([
+      { id: "host:claude:model", selected: false },
+      { id: "host:codex:model", selected: true },
+    ]);
+    choices[0].run();
+    choices[1].run();
+    expect(selections).toEqual(["claude:model"]);
+  });
+
+  it("does not publish unavailable providers or no-op default rows", () => {
+    const choices = buildModelChoiceContributions({
+      serverId: "host",
+      providers: [
+        provider({ id: "unavailable", label: "Unavailable", state: "error" }),
+        {
+          id: "empty",
+          label: "Empty",
+          modelSelection: {
+            kind: "models",
+            rows: [
+              {
+                favoriteKey: "empty:",
+                provider: "empty",
+                providerLabel: "Empty",
+                modelId: "",
+                modelLabel: "Default",
+                description: undefined,
+              },
+            ],
+          },
+        },
+      ],
+      selectedProvider: null,
+      selectedModelId: null,
+      groupLabel: "Model",
+      searchKeywords: "model switch",
+      getIcon: () => TestIcon,
+      select: () => undefined,
+    });
+
+    expect(choices).toEqual([]);
+  });
+});
@@ -0,0 +1,51 @@
+import type { AgentProvider } from "@getpaseo/protocol/agent-types";
+import type { ProviderSelectorProvider } from "@/provider-selection/provider-selection";
+import type { CommandCenterContribution, CommandCenterIcon } from "./contributions";
+
+interface ModelChoiceInput {
+  serverId: string;
+  providers: readonly ProviderSelectorProvider[];
+  selectedProvider: string | null;
+  selectedModelId: string | null;
+  groupLabel: string;
+  searchKeywords: string;
+  getIcon(provider: AgentProvider): CommandCenterIcon;
+  select(provider: AgentProvider, modelId: string): void;
+}
+
+export function buildModelChoiceContributions(
+  input: ModelChoiceInput,
+): CommandCenterContribution[] {
+  const contributions: CommandCenterContribution[] = [];
+  let rank = 0;
+  for (const provider of input.providers) {
+    if (provider.modelSelection.kind !== "models") continue;
+    const agentProvider = provider.id;
+    const icon = input.getIcon(agentProvider);
+    for (const model of provider.modelSelection.rows) {
+      if (!model.modelId) continue;
+      const modelId = model.modelId;
+      const selected = input.selectedProvider === provider.id && input.selectedModelId === modelId;
+      contributions.push({
+        id: `${input.serverId}:${provider.id}:${modelId}`,
+        group: "models",
+        groupRank: 1,
+        rank,
+        keywords: [modelId, input.searchKeywords],
+        visibility: "query",
+        run: () => {
+          if (!selected) input.select(agentProvider, modelId);
+        },
+        presentation: {
+          kind: "choice",
+          path: [input.groupLabel, provider.label, model.modelLabel],
+          icon,
+          selected,
+          testId: `command-center-model-${input.serverId}:${provider.id}:${modelId}`,
+        },
+      });
+      rank += 1;
+    }
+  }
+  return contributions;
+}
@@ -0,0 +1,20 @@
+import { withUnistyles } from "react-native-unistyles";
+import type { AgentProvider } from "@getpaseo/protocol/agent-types";
+import { getProviderIcon } from "@/components/provider-icons";
+import type { CommandCenterIcon, CommandCenterIconProps } from "./contributions";
+
+const commandCenterProviderIcons = new Map<AgentProvider, CommandCenterIcon>();
+
+export function getCommandCenterProviderIcon(provider: AgentProvider): CommandCenterIcon {
+  const cached = commandCenterProviderIcons.get(provider);
+  if (cached) return cached;
+
+  const ProviderIcon = withUnistyles(getProviderIcon(provider), (theme) => ({
+    color: theme.colors.foregroundMuted,
+  }));
+  function CommandCenterProviderIcon({ size }: CommandCenterIconProps) {
+    return <ProviderIcon size={size} />;
+  }
+  commandCenterProviderIcons.set(provider, CommandCenterProviderIcon);
+  return CommandCenterProviderIcon;
+}
@@ -0,0 +1,56 @@
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  useSyncExternalStore,
+  type ReactNode,
+} from "react";
+import type { CommandCenterContribution } from "./contributions";
+import { createCommandCenterRegistry, type CommandCenterRegistry } from "./registry";
+
+const CommandCenterRegistryContext = createContext<CommandCenterRegistry | null>(null);
+
+export function CommandCenterProvider({ children }: { children: ReactNode }) {
+  const registryRef = useRef<CommandCenterRegistry | null>(null);
+  if (!registryRef.current) registryRef.current = createCommandCenterRegistry();
+
+  return (
+    <CommandCenterRegistryContext.Provider value={registryRef.current}>
+      {children}
+    </CommandCenterRegistryContext.Provider>
+  );
+}
+
+function useCommandCenterRegistry(): CommandCenterRegistry {
+  const registry = useContext(CommandCenterRegistryContext);
+  if (!registry) throw new Error("CommandCenterProvider is required");
+  return registry;
+}
+
+export function useCommandCenterContributions() {
+  const registry = useCommandCenterRegistry();
+  return useSyncExternalStore(registry.subscribe, registry.getSnapshot, registry.getSnapshot);
+}
+
+export function useCommandCenterActions(input: {
+  sourceId: string;
+  enabled: boolean;
+  actions: readonly CommandCenterContribution[];
+}): void {
+  const registry = useCommandCenterRegistry();
+  const ownerRef = useRef({ sourceId: input.sourceId, token: Symbol(input.sourceId) });
+  if (ownerRef.current.sourceId !== input.sourceId) {
+    ownerRef.current = { sourceId: input.sourceId, token: Symbol(input.sourceId) };
+  }
+  const owner = ownerRef.current;
+
+  useEffect(() => {
+    if (!input.enabled) {
+      registry.remove(owner);
+      return;
+    }
+    registry.replace({ owner, contributions: input.actions });
+    return () => registry.remove(owner);
+  }, [input.actions, input.enabled, owner, registry]);
+}
@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import type { CommandCenterContribution, CommandCenterRegistrationOwner } from "./contributions";
+import { createCommandCenterRegistry } from "./registry";
+
+function action(id: string, rank: number): CommandCenterContribution {
+  return {
+    id,
+    group: "actions",
+    groupRank: 0,
+    rank,
+    keywords: [],
+    visibility: "always",
+    run: () => undefined,
+    presentation: { kind: "action", title: id },
+  };
+}
+
+function owner(sourceId: string): CommandCenterRegistrationOwner {
+  return { sourceId, token: Symbol(sourceId) };
+}
+
+describe("Command Center registry", () => {
+  it("atomically replaces a source and preserves a no-op snapshot", () => {
+    const registry = createCommandCenterRegistry();
+    const source = owner("root");
+    const first = [action("first", 0)];
+    let notifications = 0;
+    registry.subscribe(() => {
+      notifications += 1;
+    });
+
+    registry.replace({ owner: source, contributions: first });
+    const snapshot = registry.getSnapshot();
+    registry.replace({ owner: source, contributions: first });
+    expect(registry.getSnapshot()).toBe(snapshot);
+    expect(notifications).toBe(1);
+
+    registry.replace({ owner: source, contributions: [action("second", 0)] });
+    expect(registry.getSnapshot().contributions.map((item) => item.id)).toEqual(["root:second"]);
+    expect(notifications).toBe(2);
+  });
+
+  it("does not let stale cleanup remove a replacement owner", () => {
+    const registry = createCommandCenterRegistry();
+    const stale = owner("draft:tab");
+    const current = owner("draft:tab");
+    registry.replace({ owner: stale, contributions: [action("old", 0)] });
+    registry.replace({ owner: current, contributions: [action("new", 0)] });
+
+    registry.remove(stale);
+    expect(registry.getSnapshot().contributions.map((item) => item.id)).toEqual(["draft:tab:new"]);
+    registry.remove(current);
+    expect(registry.getSnapshot().contributions).toEqual([]);
+  });
+
+  it("orders independently of registration order and rejects duplicate active ids", () => {
+    const registry = createCommandCenterRegistry();
+    registry.replace({ owner: owner("later"), contributions: [action("z", 2)] });
+    registry.replace({ owner: owner("earlier"), contributions: [action("a", 1)] });
+    expect(registry.getSnapshot().contributions.map((item) => item.id)).toEqual([
+      "earlier:a",
+      "later:z",
+    ]);
+
+    const duplicateOwner = owner("duplicate");
+    expect(() =>
+      registry.replace({
+        owner: duplicateOwner,
+        contributions: [action("same", 0), action("same", 1)],
+      }),
+    ).toThrow("Duplicate Command Center contribution id: duplicate:same");
+  });
+});
@@ -0,0 +1,100 @@
+import type {
+  CommandCenterContribution,
+  CommandCenterContributionSnapshot,
+  CommandCenterRegistration,
+  CommandCenterRegistrationOwner,
+} from "./contributions";
+
+export interface CommandCenterRegistry {
+  getSnapshot(): CommandCenterContributionSnapshot;
+  subscribe(listener: () => void): () => void;
+  replace(registration: CommandCenterRegistration): void;
+  remove(owner: CommandCenterRegistrationOwner): void;
+}
+
+interface ActiveRegistration {
+  owner: CommandCenterRegistrationOwner;
+  contributions: readonly CommandCenterContribution[];
+}
+
+const EMPTY_SNAPSHOT: CommandCenterContributionSnapshot = { contributions: [] };
+
+function contributionId(sourceId: string, id: string): string {
+  return `${sourceId}:${id}`;
+}
+
+function compareContributions(
+  left: CommandCenterContribution,
+  right: CommandCenterContribution,
+): number {
+  if (left.groupRank !== right.groupRank) return left.groupRank - right.groupRank;
+  const groupDelta = left.group.localeCompare(right.group);
+  if (groupDelta !== 0) return groupDelta;
+  if (left.rank !== right.rank) return left.rank - right.rank;
+  return left.id.localeCompare(right.id);
+}
+
+function sameContributions(
+  left: readonly CommandCenterContribution[],
+  right: readonly CommandCenterContribution[],
+): boolean {
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+
+export function createCommandCenterRegistry(): CommandCenterRegistry {
+  const registrations = new Map<string, ActiveRegistration>();
+  const listeners = new Set<() => void>();
+  let snapshot = EMPTY_SNAPSHOT;
+
+  function publish(): void {
+    const contributions: CommandCenterContribution[] = [];
+    const ids = new Set<string>();
+
+    for (const registration of registrations.values()) {
+      for (const contribution of registration.contributions) {
+        const id = contributionId(registration.owner.sourceId, contribution.id);
+        if (ids.has(id)) {
+          throw new Error(`Duplicate Command Center contribution id: ${id}`);
+        }
+        ids.add(id);
+        contributions.push({ ...contribution, id });
+      }
+    }
+    contributions.sort(compareContributions);
+
+    if (sameContributions(snapshot.contributions, contributions)) return;
+    snapshot = contributions.length === 0 ? EMPTY_SNAPSHOT : { contributions };
+    for (const listener of listeners) listener();
+  }
+
+  return {
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    replace(registration) {
+      const current = registrations.get(registration.owner.sourceId);
+      if (
+        current?.owner.token === registration.owner.token &&
+        sameContributions(current.contributions, registration.contributions)
+      ) {
+        return;
+      }
+      const ids = new Set<string>();
+      for (const contribution of registration.contributions) {
+        const id = contributionId(registration.owner.sourceId, contribution.id);
+        if (ids.has(id)) throw new Error(`Duplicate Command Center contribution id: ${id}`);
+        ids.add(id);
+      }
+      registrations.set(registration.owner.sourceId, registration);
+      publish();
+    },
+    remove(owner) {
+      const current = registrations.get(owner.sourceId);
+      if (current?.owner.token !== owner.token) return;
+      registrations.delete(owner.sourceId);
+      publish();
+    },
+  };
+}
@@ -0,0 +1,105 @@
+import { describe, expect, it } from "vitest";
+import type { CommandCenterContribution } from "./contributions";
+import {
+  buildContributionSections,
+  moveActiveResultId,
+  preserveActiveResultId,
+  projectCommandCenterRows,
+  type CommandCenterWorkspaceResult,
+} from "./results";
+
+function contribution(input: {
+  id: string;
+  group: string;
+  groupRank: number;
+  visibility?: "always" | "query";
+}): CommandCenterContribution {
+  return {
+    ...input,
+    rank: 0,
+    keywords: [input.id],
+    visibility: input.visibility ?? "always",
+    run: () => undefined,
+    presentation: {
+      kind: "action",
+      title: input.id,
+      sectionTitle: input.group,
+    },
+  };
+}
+
+function workspace(id: string): CommandCenterWorkspaceResult {
+  return {
+    kind: "workspace",
+    id,
+    title: id,
+    subtitle: "host",
+    searchText: id,
+    run: () => undefined,
+  };
+}
+
+function sectionResultIds(sections: ReturnType<typeof buildContributionSections>): string[] {
+  const ids: string[] = [];
+  for (const section of sections) {
+    for (const result of section.results) ids.push(result.id);
+  }
+  return ids;
+}
+
+describe("Command Center result projection", () => {
+  it("query-gates model choices and creates one flat row index", () => {
+    const contributions = [
+      contribution({ id: "settings", group: "actions", groupRank: 0 }),
+      contribution({ id: "opus", group: "models", groupRank: 1, visibility: "query" }),
+    ];
+    const emptySections = buildContributionSections(contributions, "");
+    expect(sectionResultIds(emptySections)).toEqual(["settings"]);
+
+    const sections = buildContributionSections(contributions, "o");
+    const projection = projectCommandCenterRows([
+      ...sections,
+      { id: "workspaces", rank: 2, title: "Workspaces", results: [workspace("workspace:1")] },
+    ]);
+    expect(projection.rows.map((row) => row.key)).toEqual([
+      "section:models",
+      "opus",
+      "section:workspaces",
+      "workspace:1",
+    ]);
+    expect(projection.rowIndexByResultId.get("workspace:1")).toBe(3);
+    expect(projection.offsets).toEqual([0, 32, 68, 117]);
+  });
+
+  it("preserves active selection by id and falls back to the first result", () => {
+    const first = workspace("workspace:first");
+    const second = workspace("workspace:second");
+    expect(preserveActiveResultId(second.id, [first, second])).toBe(second.id);
+    expect(preserveActiveResultId("missing", [first, second])).toBe(first.id);
+    expect(preserveActiveResultId(first.id, [])).toBeNull();
+  });
+
+  it("wraps keyboard selection in both directions", () => {
+    const first = workspace("workspace:first");
+    const second = workspace("workspace:second");
+    expect(moveActiveResultId(second.id, [first, second], "next")).toBe(first.id);
+    expect(moveActiveResultId(first.id, [first, second], "previous")).toBe(second.id);
+  });
+
+  it("keeps keyboard selection aligned with rows beyond the render window", () => {
+    const workspaces = Array.from({ length: 200 }, (_, index) => workspace(`workspace:${index}`));
+    const projection = projectCommandCenterRows([
+      { id: "workspaces", rank: 0, title: "Workspaces", results: workspaces },
+    ]);
+
+    let activeId: string | null = workspaces[0].id;
+    for (let index = 0; index < 150; index += 1) {
+      activeId = moveActiveResultId(activeId, projection.selectableResults, "next");
+    }
+
+    const targetId = workspaces[150].id;
+    expect(activeId).toBe(targetId);
+    expect(projection.rowIndexByResultId.get(targetId)).toBe(151);
+    expect(projection.offsets[151]).toBe(32 + 150 * 56);
+  });
+});
@@ -0,0 +1,181 @@
+import type { AggregatedAgent } from "@/hooks/use-aggregated-agents";
+import type { CommandCenterContribution } from "./contributions";
+
+export interface CommandCenterWorkspaceResult {
+  kind: "workspace";
+  id: string;
+  title: string;
+  subtitle: string;
+  searchText: string;
+  run(): void;
+}
+
+export interface CommandCenterAgentResult {
+  kind: "agent";
+  id: string;
+  agent: AggregatedAgent;
+  title: string;
+  subtitle: string;
+  searchText: string;
+  run(): void;
+}
+
+export interface CommandCenterContributionResult {
+  kind: "contribution";
+  id: string;
+  contribution: CommandCenterContribution;
+  searchText: string;
+  run(): void | Promise<void>;
+}
+
+export type CommandCenterResult =
+  | CommandCenterWorkspaceResult
+  | CommandCenterAgentResult
+  | CommandCenterContributionResult;
+
+export interface CommandCenterResultSection {
+  id: string;
+  rank: number;
+  title?: string;
+  results: readonly CommandCenterResult[];
+}
+
+interface MutableCommandCenterResultSection {
+  id: string;
+  rank: number;
+  title?: string;
+  results: CommandCenterResult[];
+}
+
+export type CommandCenterListRow =
+  | { kind: "section"; key: string; title?: string; divider: boolean; height: number }
+  | { kind: "result"; key: string; result: CommandCenterResult; height: number };
+
+export interface CommandCenterListProjection {
+  rows: readonly CommandCenterListRow[];
+  selectableResults: readonly CommandCenterResult[];
+  rowIndexByResultId: ReadonlyMap<string, number>;
+  offsets: readonly number[];
+}
+
+function matchesQuery(searchText: string, query: string): boolean {
+  const normalized = query.trim().toLowerCase();
+  return !normalized || searchText.includes(normalized);
+}
+
+function contributionSearchText(contribution: CommandCenterContribution): string {
+  const presentationText =
+    contribution.presentation.kind === "action"
+      ? [contribution.presentation.title, contribution.presentation.subtitle ?? ""]
+      : contribution.presentation.path;
+  return [...presentationText, ...contribution.keywords].join(" ").toLowerCase();
+}
+
+function resultHeight(result: CommandCenterResult): number {
+  if (result.kind === "workspace" || result.kind === "agent") return 56;
+  if (result.contribution.presentation.kind === "action") {
+    return result.contribution.presentation.subtitle ? 56 : 36;
+  }
+  return 36;
+}
+
+export function buildContributionSections(
+  contributions: readonly CommandCenterContribution[],
+  query: string,
+): CommandCenterResultSection[] {
+  const groups = new Map<string, MutableCommandCenterResultSection>();
+  const hasQuery = Boolean(query.trim());
+
+  for (const contribution of contributions) {
+    if (contribution.visibility === "query" && !hasQuery) continue;
+    const searchText = contributionSearchText(contribution);
+    if (!matchesQuery(searchText, query)) continue;
+    const existing = groups.get(contribution.group);
+    const title =
+      contribution.presentation.kind === "action"
+        ? contribution.presentation.sectionTitle
+        : undefined;
+    const section = existing ?? {
+      id: contribution.group,
+      rank: contribution.groupRank,
+      title,
+      results: [],
+    };
+    section.results.push({
+      kind: "contribution",
+      id: contribution.id,
+      contribution,
+      searchText,
+      run: contribution.run,
+    });
+    groups.set(contribution.group, section);
+  }
+
+  return [...groups.values()].sort(
+    (left, right) => left.rank - right.rank || left.id.localeCompare(right.id),
+  );
+}
+
+export function projectCommandCenterRows(
+  sections: readonly CommandCenterResultSection[],
+): CommandCenterListProjection {
+  const populated = sections
+    .filter((section) => section.results.length > 0)
+    .sort((left, right) => left.rank - right.rank || left.id.localeCompare(right.id));
+  const rows: CommandCenterListRow[] = [];
+  const selectableResults: CommandCenterResult[] = [];
+  const rowIndexByResultId = new Map<string, number>();
+  const offsets: number[] = [];
+  let offset = 0;
+
+  for (const [sectionIndex, section] of populated.entries()) {
+    const divider = sectionIndex > 0;
+    let sectionHeight = 0;
+    if (section.title && divider) sectionHeight = 49;
+    if (section.title && !divider) sectionHeight = 32;
+    if (!section.title && divider) sectionHeight = 17;
+    if (sectionHeight > 0) {
+      offsets.push(offset);
+      rows.push({
+        kind: "section",
+        key: `section:${section.id}`,
+        title: section.title,
+        divider,
+        height: sectionHeight,
+      });
+      offset += sectionHeight;
+    }
+    for (const result of section.results) {
+      const height = resultHeight(result);
+      offsets.push(offset);
+      rowIndexByResultId.set(result.id, rows.length);
+      rows.push({ kind: "result", key: result.id, result, height });
+      selectableResults.push(result);
+      offset += height;
+    }
+  }
+
+  return { rows, selectableResults, rowIndexByResultId, offsets };
+}
+
+export function preserveActiveResultId(
+  activeId: string | null,
+  results: readonly CommandCenterResult[],
+): string | null {
+  if (activeId && results.some((result) => result.id === activeId)) return activeId;
+  return results[0]?.id ?? null;
+}
+
+export function moveActiveResultId(
+  activeId: string | null,
+  results: readonly CommandCenterResult[],
+  direction: "next" | "previous",
+): string | null {
+  if (results.length === 0) return null;
+  const current = results.findIndex((result) => result.id === activeId);
+  const delta = direction === "next" ? 1 : -1;
+  let start = current;
+  if (current < 0 && direction === "previous") start = 0;
+  const next = (start + delta + results.length) % results.length;
+  return results[next].id;
+}
@@ -230,7 +230,6 @@ const styles = StyleSheet.create((theme) => ({
  },
 }));

-const SEARCH_INPUT_STYLE = [styles.searchInput, isWeb && { outlineStyle: "none" }];
 const WEB_EXIT_DURATION_MS = 160;

 function SheetBackground({ style }: BottomSheetBackgroundProps) {
@@ -373,7 +372,7 @@ export function SheetHeaderView({
          <Search size={theme.iconSize.md} color={theme.colors.foregroundMuted} />
          <AdaptiveTextInput
            // @ts-expect-error - outlineStyle is web-only
-            style={SEARCH_INPUT_STYLE}
+            style={[styles.searchInput, isWeb && { outlineStyle: "none" }]}
            placeholder={search.placeholder ?? t("common.actions.search")}
            resetKey={search.resetKey}
            onChangeText={handleSearchChange}
@@ -430,7 +429,7 @@ export function InlineHeaderView({ header }: { header: SheetHeader }) {
          <Search size={theme.iconSize.sm} color={theme.colors.foregroundMuted} />
          <AdaptiveTextInput
            // @ts-expect-error - outlineStyle is web-only
-            style={SEARCH_INPUT_STYLE}
+            style={[styles.searchInput, isWeb && { outlineStyle: "none" }]}
            placeholder={header.search.placeholder ?? t("common.actions.search")}
            resetKey={header.search.resetKey}
            onChangeText={header.search.onChange}
@@ -45,6 +45,7 @@ import {
 } from "@/add-project-flow/model";
 import {
  buildAddProjectMethods,
+  addProjectMethodEmptyText,
  buildCloneLocationOptions,
  buildManualGithubRepositoryChoices,
  buildSuggestedParentDirectories,
@@ -161,9 +162,10 @@ function progressText(page: AddProjectPage): string {
  return "Adding project...";
 }

-function emptyText(page: AddProjectPage): string {
+function emptyText(page: AddProjectPage, host: AddProjectHost | null): string {
  if (page.kind === "host") return "No connected hosts";
  if (page.kind === "github-search") return "Enter a GitHub URL or owner/repo";
+  if (page.kind === "method") return addProjectMethodEmptyText(host);
  return "No matching options";
 }

@@ -297,6 +299,8 @@ export function AddProjectFlow({ request, onClose }: AddProjectFlowProps) {
  const hostIds = useMemo(() => hosts.map((host) => host.serverId), [hosts]);
  const connectionStatuses = useHostRuntimeConnectionStatuses(hostIds);
  const projectAddByHost = useHostFeatureMap(hostIds, "projectAdd");
+  // COMPAT(stableProjectIdentity): added in v0.1.109, remove gate after 2027-01-15.
+  const stableProjectIdentityByHost = useHostFeatureMap(hostIds, "stableProjectIdentity");
  // COMPAT(projectGithubClone): added in v0.1.108, remove gate after 2027-01-15.
  const githubCloneByHost = useHostFeatureMap(hostIds, "projectGithubClone");
  // COMPAT(workspaceGithubRepositorySearch): added in v0.1.108, remove gate after 2027-01-15.
@@ -308,7 +312,9 @@ export function AddProjectFlow({ request, onClose }: AddProjectFlowProps) {
    () =>
      hosts.flatMap((host) => {
        if (connectionStatuses.get(host.serverId) !== "online") return [];
-        const canAddProject = projectAddByHost.get(host.serverId) === true;
+        const canAddProject =
+          projectAddByHost.get(host.serverId) === true &&
+          stableProjectIdentityByHost.get(host.serverId) === true;
        return [
          {
            serverId: host.serverId,
@@ -329,6 +335,7 @@ export function AddProjectFlow({ request, onClose }: AddProjectFlowProps) {
      hosts,
      localServerId,
      projectAddByHost,
+      stableProjectIdentityByHost,
    ],
  );
  const [state, setState] = useState(() =>
@@ -893,7 +900,7 @@ export function AddProjectFlow({ request, onClose }: AddProjectFlowProps) {
            rows.length === 0 &&
            page.kind !== "new-directory-name" ? (
              <Text style={styles.stateText} testID="add-project-flow-empty">
-                {emptyText(page)}
+                {emptyText(page, host ?? null)}
              </Text>
            ) : null}
          </ScrollView>
@@ -394,6 +394,7 @@ export function AgentList({
        serverId,
        agentId,
        workspaceId: agent.workspaceId,
+        pin: true,
      });
    },
    [isActionSheetVisible, onAgentSelect],
@@ -544,7 +545,7 @@ export function AgentList({
            </Text>
            <View style={styles.sheetButtonRow}>
              <Pressable
-                style={SHEET_CANCEL_BUTTON_STYLE}
+                style={[styles.sheetButton, styles.sheetCancelButton]}
                onPress={handleCloseActionSheet}
                testID="agent-action-cancel"
              >
@@ -552,7 +553,7 @@ export function AgentList({
              </Pressable>
              <Pressable
                disabled={isActionDaemonUnavailable}
-                style={SHEET_ARCHIVE_BUTTON_STYLE}
+                style={[styles.sheetButton, styles.sheetArchiveButton]}
                onPress={handleArchiveAgent}
                testID="agent-action-archive"
              >
@@ -789,6 +790,3 @@ const styles = StyleSheet.create((theme) => ({
    fontSize: theme.fontSize.base,
  },
 }));
-
-const SHEET_CANCEL_BUTTON_STYLE = [styles.sheetButton, styles.sheetCancelButton];
-const SHEET_ARCHIVE_BUTTON_STYLE = [styles.sheetButton, styles.sheetArchiveButton];
@@ -9,6 +9,7 @@ import { useHostRuntimeClient, useHostRuntimeIsConnected } from "@/runtime/host-
 import { useKeyboardShiftStyle } from "@/hooks/use-keyboard-shift-style";
 import { Button } from "@/components/ui/button";
 import type { Theme } from "@/styles/theme";
+import { toErrorMessage } from "@/utils/error-messages";

 interface ArchivedAgentCalloutProps {
  serverId: string;
@@ -21,6 +22,7 @@ export function ArchivedAgentCallout({ serverId, agentId }: ArchivedAgentCallout
  const client = useHostRuntimeClient(serverId);
  const isConnected = useHostRuntimeIsConnected(serverId);
  const [isUnarchiving, setIsUnarchiving] = useState(false);
+  const [unarchiveError, setUnarchiveError] = useState<string | null>(null);

  const { style: keyboardAnimatedStyle } = useKeyboardShiftStyle({ mode: "translate" });

@@ -32,10 +34,11 @@ export function ArchivedAgentCallout({ serverId, agentId }: ArchivedAgentCallout
  const handleUnarchive = useCallback(async () => {
    if (!client || !isConnected || isUnarchiving) return;
    setIsUnarchiving(true);
+    setUnarchiveError(null);
    try {
      await client.refreshAgent(agentId);
    } catch (error) {
-      console.error("[ArchivedAgentCallout] Failed to unarchive agent:", error);
+      setUnarchiveError(toErrorMessage(error));
      setIsUnarchiving(false);
    }
  }, [client, isConnected, isUnarchiving, agentId]);
@@ -44,16 +47,23 @@ export function ArchivedAgentCallout({ serverId, agentId }: ArchivedAgentCallout
    <Animated.View style={containerStyle}>
      <View style={styles.inputAreaContainer}>
        <View style={styles.inputAreaContent}>
-          <View style={styles.callout}>
-            <Text style={styles.calloutText}>{t("agentPanel.archived.callout")}</Text>
-            <Button
-              size="sm"
-              variant="secondary"
-              onPress={handleUnarchive}
-              disabled={!isConnected || isUnarchiving}
-            >
-              {t("agentPanel.archived.unarchive")}
-            </Button>
+          <View style={styles.calloutStack}>
+            <View style={styles.callout}>
+              <Text style={styles.calloutText}>{t("agentPanel.archived.callout")}</Text>
+              <Button
+                size="sm"
+                variant="secondary"
+                onPress={handleUnarchive}
+                disabled={!isConnected || isUnarchiving}
+              >
+                {t("agentPanel.archived.unarchive")}
+              </Button>
+            </View>
+            {unarchiveError ? (
+              <Text style={styles.errorText} testID="agent-unarchive-error">
+                {unarchiveError}
+              </Text>
+            ) : null}
          </View>
        </View>
      </View>
@@ -97,8 +107,16 @@ const styles = StyleSheet.create((theme: Theme) => ({
      md: theme.spacing[6],
    },
  },
+  calloutStack: {
+    gap: theme.spacing[2],
+  },
  calloutText: {
    color: theme.colors.foregroundMuted,
    fontSize: theme.fontSize.base,
  },
+  errorText: {
+    color: theme.colors.statusDanger,
+    fontSize: theme.fontSize.sm,
+    textAlign: "center",
+  },
 })) as unknown as Record<string, object>;
@@ -1,726 +0,0 @@
-import {
-  Modal,
-  Pressable,
-  ScrollView,
-  Text,
-  TextInput,
-  View,
-  type PressableStateCallbackType,
-} from "react-native";
-import { memo, useCallback, useEffect, useMemo, useRef, type ReactNode } from "react";
-import { useTranslation } from "react-i18next";
-import { Folder, Home, Plus, Settings } from "lucide-react-native";
-import { StyleSheet, useUnistyles, withUnistyles } from "react-native-unistyles";
-import {
-  useCommandCenter,
-  type CommandCenterActionItem,
-  type CommandCenterAgentItem,
-  type CommandCenterItem,
-  type CommandCenterWorkspaceItem,
-} from "@/hooks/use-command-center";
-import { AgentStatusDot } from "@/components/agent-status-dot";
-import { Shortcut } from "@/components/ui/shortcut";
-import { isNative, isWeb } from "@/constants/platform";
-import { useIsCompactFormFactor } from "@/constants/layout";
-import {
-  IsolatedBottomSheetModal,
-  useIsolatedBottomSheetVisibility,
-} from "@/components/ui/isolated-bottom-sheet-modal";
-import {
-  BottomSheetBackdrop,
-  BottomSheetScrollView,
-  BottomSheetTextInput,
-} from "@gorhom/bottom-sheet";
-
-const ThemedBottomSheetTextInput = withUnistyles(BottomSheetTextInput, (theme) => ({
-  placeholderTextColor: theme.colors.foregroundMuted,
-}));
-const ThemedFolder = withUnistyles(Folder, (theme) => ({
-  color: theme.colors.foregroundMuted,
-}));
-
-interface CommandCenterRowProps {
-  active: boolean;
-  children: ReactNode;
-  onPress: () => void;
-  registerRow: (el: View | null) => void;
-  onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-}
-
-const CommandCenterRow = memo(function CommandCenterRow({
-  active,
-  children,
-  onPress,
-  registerRow,
-  onLayout,
-}: CommandCenterRowProps) {
-  const { theme } = useUnistyles();
-
-  const pressableStyle = useCallback(
-    ({ hovered, pressed }: PressableStateCallbackType & { hovered?: boolean }) => [
-      styles.row,
-      (Boolean(hovered) || pressed || active) && {
-        backgroundColor: theme.colors.surface1,
-      },
-    ],
-    [active, theme.colors.surface1],
-  );
-
-  return (
-    <Pressable ref={registerRow} style={pressableStyle} onPress={onPress} onLayout={onLayout}>
-      {children}
-    </Pressable>
-  );
-});
-
-interface CommandCenterRowContainerProps {
-  item: CommandCenterItem;
-  rowIndex: number;
-  active: boolean;
-  rowRefs: React.MutableRefObject<Map<number, View>>;
-  onSelect: (item: CommandCenterItem) => void;
-  onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  children: ReactNode;
-}
-
-function CommandCenterRowContainer({
-  item,
-  rowIndex,
-  active,
-  rowRefs,
-  onSelect,
-  onLayout,
-  children,
-}: CommandCenterRowContainerProps) {
-  const handlePress = useCallback(() => onSelect(item), [onSelect, item]);
-  const registerRow = useCallback(
-    (el: View | null) => {
-      if (el) rowRefs.current.set(rowIndex, el);
-      else rowRefs.current.delete(rowIndex);
-    },
-    [rowRefs, rowIndex],
-  );
-  return (
-    <CommandCenterRow
-      active={active}
-      registerRow={registerRow}
-      onPress={handlePress}
-      onLayout={onLayout}
-    >
-      {children}
-    </CommandCenterRow>
-  );
-}
-
-interface CommandCenterActionRowProps {
-  item: CommandCenterActionItem;
-  rowIndex: number;
-  active: boolean;
-  rowRefs: React.MutableRefObject<Map<number, View>>;
-  onLayout?: (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: CommandCenterItem) => void;
-}
-
-function CommandCenterActionRow({
-  item,
-  rowIndex,
-  active,
-  rowRefs,
-  onLayout,
-  onSelect,
-}: CommandCenterActionRowProps) {
-  const { theme } = useUnistyles();
-  let actionIcon: React.ReactNode = null;
-  if (item.icon === "plus") {
-    actionIcon = <Plus size={16} strokeWidth={2.4} color={theme.colors.foregroundMuted} />;
-  } else if (item.icon === "settings") {
-    actionIcon = <Settings size={16} strokeWidth={2.2} color={theme.colors.foregroundMuted} />;
-  } else if (item.icon === "home") {
-    actionIcon = <Home size={16} strokeWidth={2.2} color={theme.colors.foregroundMuted} />;
-  }
-  const titleStyle = useMemo(
-    () => [styles.title, { color: theme.colors.foreground }],
-    [theme.colors.foreground],
-  );
-  return (
-    <CommandCenterRowContainer
-      item={item}
-      rowIndex={rowIndex}
-      active={active}
-      rowRefs={rowRefs}
-      onSelect={onSelect}
-      onLayout={onLayout}
-    >
-      <View style={styles.rowContent}>
-        <View style={styles.rowMain}>
-          {actionIcon ? <View style={styles.iconSlot}>{actionIcon}</View> : null}
-          <View style={styles.textContent}>
-            <Text style={titleStyle} numberOfLines={1}>
-              {item.title}
-            </Text>
-          </View>
-        </View>
-        {item.shortcutKeys ? (
-          <Shortcut chord={item.shortcutKeys} style={styles.rowShortcut} />
-        ) : null}
-      </View>
-    </CommandCenterRowContainer>
-  );
-}
-
-interface CommandCenterAgentRowContentProps {
-  item: CommandCenterAgentItem;
-}
-
-function CommandCenterAgentRowContent({ item }: CommandCenterAgentRowContentProps) {
-  const { theme } = useUnistyles();
-  const agent = item.agent;
-  const titleStyle = useMemo(
-    () => [styles.title, { color: theme.colors.foreground }],
-    [theme.colors.foreground],
-  );
-  const subtitleStyle = useMemo(
-    () => [styles.subtitle, { color: theme.colors.foregroundMuted }],
-    [theme.colors.foregroundMuted],
-  );
-  return (
-    <View style={styles.rowContent} testID={`command-center-agent-${agent.serverId}:${agent.id}`}>
-      <View style={styles.rowMain}>
-        <View style={styles.iconSlot}>
-          <AgentStatusDot
-            status={agent.status}
-            requiresAttention={agent.requiresAttention}
-            showInactive
-          />
-        </View>
-        <View style={styles.textContent}>
-          <Text style={titleStyle} numberOfLines={1}>
-            {item.title}
-          </Text>
-          <Text style={subtitleStyle} numberOfLines={1} testID="command-center-agent-subtitle">
-            {item.subtitle}
-          </Text>
-        </View>
-      </View>
-    </View>
-  );
-}
-
-interface AgentItemsSectionProps {
-  agentItems: CommandCenterAgentItem[];
-  startIndex: number;
-  activeIndex: number;
-  rowRefs: React.MutableRefObject<Map<number, View>>;
-  onRowLayout: (
-    rowIndex: number,
-  ) => (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: CommandCenterItem) => void;
-  sectionDividerStyle: React.ComponentProps<typeof View>["style"];
-  sectionLabelStyle: React.ComponentProps<typeof Text>["style"];
-}
-
-function AgentItemsSection({
-  agentItems,
-  startIndex,
-  activeIndex,
-  rowRefs,
-  onRowLayout,
-  onSelect,
-  sectionDividerStyle,
-  sectionLabelStyle,
-}: AgentItemsSectionProps) {
-  const { t } = useTranslation();
-
-  return (
-    <>
-      {startIndex > 0 ? <View style={sectionDividerStyle} /> : null}
-      <Text style={sectionLabelStyle}>{t("shell.commandCenter.agents")}</Text>
-      {agentItems.map((item, index) => {
-        const rowIndex = startIndex + index;
-        const agent = item.agent;
-        return (
-          <CommandCenterRowContainer
-            key={`${agent.serverId}:${agent.id}`}
-            item={item}
-            rowIndex={rowIndex}
-            active={rowIndex === activeIndex}
-            rowRefs={rowRefs}
-            onLayout={onRowLayout(rowIndex)}
-            onSelect={onSelect}
-          >
-            <CommandCenterAgentRowContent item={item} />
-          </CommandCenterRowContainer>
-        );
-      })}
-    </>
-  );
-}
-
-interface WorkspaceItemsSectionProps {
-  workspaceItems: CommandCenterWorkspaceItem[];
-  startIndex: number;
-  activeIndex: number;
-  rowRefs: React.MutableRefObject<Map<number, View>>;
-  onRowLayout: (
-    rowIndex: number,
-  ) => (event: { nativeEvent: { layout: { y: number; height: number } } }) => void;
-  onSelect: (item: CommandCenterItem) => void;
-  sectionDividerStyle: React.ComponentProps<typeof View>["style"];
-  sectionLabelStyle: React.ComponentProps<typeof Text>["style"];
-}
-
-function WorkspaceItemsSection({
-  workspaceItems,
-  startIndex,
-  activeIndex,
-  rowRefs,
-  onRowLayout,
-  onSelect,
-  sectionDividerStyle,
-  sectionLabelStyle,
-}: WorkspaceItemsSectionProps) {
-  const { t } = useTranslation();
-
-  return (
-    <>
-      {startIndex > 0 ? <View style={sectionDividerStyle} /> : null}
-      <Text style={sectionLabelStyle}>{t("shell.commandCenter.workspaces")}</Text>
-      {workspaceItems.map((item, index) => {
-        const rowIndex = startIndex + index;
-        return (
-          <CommandCenterRowContainer
-            key={`${item.serverId}:${item.workspaceId}`}
-            item={item}
-            rowIndex={rowIndex}
-            active={rowIndex === activeIndex}
-            rowRefs={rowRefs}
-            onSelect={onSelect}
-            onLayout={onRowLayout(rowIndex)}
-          >
-            <View
-              style={styles.rowContent}
-              testID={`command-center-workspace-${item.serverId}:${item.workspaceId}`}
-            >
-              <View style={styles.rowMain}>
-                <View style={styles.iconSlot}>
-                  <ThemedFolder size={16} strokeWidth={2.2} />
-                </View>
-                <View style={styles.textContent}>
-                  <Text style={styles.title} numberOfLines={1}>
-                    {item.title}
-                  </Text>
-                  <Text style={styles.subtitle} numberOfLines={1}>
-                    {item.subtitle}
-                  </Text>
-                </View>
-              </View>
-            </View>
-          </CommandCenterRowContainer>
-        );
-      })}
-    </>
-  );
-}
-
-export function CommandCenter() {
-  const { theme } = useUnistyles();
-  const { t } = useTranslation();
-  const {
-    open,
-    inputRef,
-    query,
-    setQuery,
-    activeIndex,
-    items,
-    handleClose,
-    handleSelectItem,
-    handleKeyEvent,
-  } = useCommandCenter();
-  const isCompact = useIsCompactFormFactor();
-  const showBottomSheet = isCompact && isNative;
-  const rowRefs = useRef<Map<number, View>>(new Map());
-  const rowLayouts = useRef<Map<number, { y: number; height: number }>>(new Map());
-  const resultsRef = useRef<ScrollView>(null);
-  const nativeScrollY = useRef(0);
-  const nativeViewHeight = useRef(0);
-  // BottomSheetTextInput wraps a different TextInput type (from react-native-gesture-handler).
-  // Use a loose ref to avoid the type mismatch — same pattern as AdaptiveTextInput.
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const bottomSheetInputRef = useRef<any>(null);
-
-  const { sheetRef, handleSheetChange, handleSheetDismiss } = useIsolatedBottomSheetVisibility({
-    visible: open,
-    isEnabled: showBottomSheet,
-    onClose: handleClose,
-  });
-
-  // Focus the bottom sheet input when the sheet opens on mobile
-  useEffect(() => {
-    if (showBottomSheet && open) {
-      const id = setTimeout(() => bottomSheetInputRef.current?.focus(), 300);
-      return () => clearTimeout(id);
-    }
-  }, [showBottomSheet, open]);
-
-  const renderBackdrop = useCallback(
-    (props: React.ComponentProps<typeof BottomSheetBackdrop>) => (
-      <BottomSheetBackdrop {...props} disappearsOnIndex={-1} appearsOnIndex={0} opacity={0.45} />
-    ),
-    [],
-  );
-
-  // Scroll active row into view
-  useEffect(() => {
-    if (!open) return;
-
-    if (isWeb) {
-      const row = rowRefs.current.get(activeIndex);
-      if (!row || typeof document === "undefined") return;
-      const scrollNode =
-        (
-          resultsRef.current as
-            | (ScrollView & {
-                getScrollableNode?: () => HTMLElement | null;
-              })
-            | null
-        )?.getScrollableNode?.() ?? null;
-      const rowEl = row as unknown as HTMLElement;
-
-      if (!scrollNode) {
-        rowEl.scrollIntoView?.({ block: "nearest" });
-        return;
-      }
-
-      const rowTop = rowEl.offsetTop;
-      const rowBottom = rowTop + rowEl.offsetHeight;
-      const visibleTop = scrollNode.scrollTop;
-      const visibleBottom = visibleTop + scrollNode.clientHeight;
-
-      if (rowTop < visibleTop) {
-        scrollNode.scrollTop = rowTop;
-        return;
-      }
-
-      if (rowBottom > visibleBottom) {
-        scrollNode.scrollTop = rowBottom - scrollNode.clientHeight;
-      }
-      return;
-    }
-
-    // Native: use onLayout-measured positions
-    const layout = rowLayouts.current.get(activeIndex);
-    if (!layout || !resultsRef.current) return;
-
-    const rowTop = layout.y;
-    const rowBottom = rowTop + layout.height;
-    const visibleTop = nativeScrollY.current;
-    const visibleBottom = visibleTop + nativeViewHeight.current;
-
-    if (rowTop < visibleTop) {
-      resultsRef.current.scrollTo?.({ y: rowTop, animated: true });
-    } else if (rowBottom > visibleBottom) {
-      resultsRef.current.scrollTo?.({
-        y: rowBottom - nativeViewHeight.current,
-        animated: true,
-      });
-    }
-  }, [activeIndex, open]);
-
-  const handleRowLayout = useCallback(
-    (rowIndex: number) => (event: { nativeEvent: { layout: { y: number; height: number } } }) => {
-      rowLayouts.current.set(rowIndex, {
-        y: event.nativeEvent.layout.y,
-        height: event.nativeEvent.layout.height,
-      });
-    },
-    [],
-  );
-
-  const actionItems = useMemo(() => items.filter((item) => item.kind === "action"), [items]);
-  const workspaceItems = useMemo(() => items.filter((item) => item.kind === "workspace"), [items]);
-  const agentItems = useMemo(() => items.filter((item) => item.kind === "agent"), [items]);
-
-  const panelStyle = useMemo(
-    () => [
-      styles.panel,
-      { borderColor: theme.colors.border, backgroundColor: theme.colors.surface0 },
-    ],
-    [theme.colors.border, theme.colors.surface0],
-  );
-  const headerStyle = useMemo(
-    () => [styles.header, { borderBottomColor: theme.colors.border }],
-    [theme.colors.border],
-  );
-  const inputStyle = useMemo(
-    () => [styles.input, { color: theme.colors.foreground }],
-    [theme.colors.foreground],
-  );
-  const emptyTextStyle = useMemo(
-    () => [styles.emptyText, { color: theme.colors.foregroundMuted }],
-    [theme.colors.foregroundMuted],
-  );
-  const sectionLabelStyle = useMemo(
-    () => [styles.sectionLabel, { color: theme.colors.foregroundMuted }],
-    [theme.colors.foregroundMuted],
-  );
-  const sectionDividerStyle = useMemo(
-    () => [styles.sectionDivider, { backgroundColor: theme.colors.border }],
-    [theme.colors.border],
-  );
-  const sheetBackgroundStyle = useMemo(
-    () => ({ backgroundColor: theme.colors.surface0 }),
-    [theme.colors.surface0],
-  );
-  const sheetHandleStyle = useMemo(
-    () => ({ backgroundColor: theme.colors.palette.zinc[600] }),
-    [theme.colors.palette.zinc],
-  );
-
-  const handleKeyPress = useCallback(
-    ({ nativeEvent: { key } }: { nativeEvent: { key: string } }) => {
-      handleKeyEvent(key);
-    },
-    [handleKeyEvent],
-  );
-
-  const handleSubmitEditing = useCallback(() => {
-    handleKeyEvent("Enter");
-  }, [handleKeyEvent]);
-
-  const snapPoints = useMemo(() => ["60%", "90%"], []);
-
-  const resultList =
-    items.length === 0 ? (
-      <Text style={emptyTextStyle}>{t("shell.commandCenter.noMatches")}</Text>
-    ) : (
-      <>
-        {actionItems.length > 0 ? (
-          <>
-            <Text style={sectionLabelStyle}>{t("shell.commandCenter.actions")}</Text>
-            {actionItems.map((item, index) => (
-              <CommandCenterActionRow
-                key={`action:${item.id}`}
-                item={item}
-                rowIndex={index}
-                active={index === activeIndex}
-                rowRefs={rowRefs}
-                onLayout={handleRowLayout(index)}
-                onSelect={handleSelectItem}
-              />
-            ))}
-          </>
-        ) : null}
-
-        {workspaceItems.length > 0 ? (
-          <WorkspaceItemsSection
-            workspaceItems={workspaceItems}
-            startIndex={actionItems.length}
-            activeIndex={activeIndex}
-            rowRefs={rowRefs}
-            onRowLayout={handleRowLayout}
-            onSelect={handleSelectItem}
-            sectionDividerStyle={sectionDividerStyle}
-            sectionLabelStyle={sectionLabelStyle}
-          />
-        ) : null}
-
-        {agentItems.length > 0 ? (
-          <AgentItemsSection
-            agentItems={agentItems}
-            startIndex={actionItems.length + workspaceItems.length}
-            activeIndex={activeIndex}
-            rowRefs={rowRefs}
-            onRowLayout={handleRowLayout}
-            onSelect={handleSelectItem}
-            sectionDividerStyle={sectionDividerStyle}
-            sectionLabelStyle={sectionLabelStyle}
-          />
-        ) : null}
-      </>
-    );
-
-  // Mobile: bottom sheet
-  if (showBottomSheet) {
-    return (
-      <IsolatedBottomSheetModal
-        ref={sheetRef}
-        snapPoints={snapPoints}
-        index={0}
-        enableDynamicSizing={false}
-        onChange={handleSheetChange}
-        onDismiss={handleSheetDismiss}
-        backdropComponent={renderBackdrop}
-        enablePanDownToClose
-        backgroundStyle={sheetBackgroundStyle}
-        handleIndicatorStyle={sheetHandleStyle}
-        keyboardBehavior="extend"
-        keyboardBlurBehavior="restore"
-        accessible={false}
-      >
-        <View style={styles.bottomSheetHeader}>
-          <ThemedBottomSheetTextInput
-            testID="command-center-input"
-            ref={bottomSheetInputRef as unknown as React.Ref<never>}
-            value={query}
-            onChangeText={setQuery}
-            onKeyPress={handleKeyPress}
-            onSubmitEditing={handleSubmitEditing}
-            placeholder={t("shell.commandCenter.placeholder")}
-            style={inputStyle}
-            autoCapitalize="none"
-            autoCorrect={false}
-            autoFocus
-          />
-        </View>
-        <BottomSheetScrollView
-          contentContainerStyle={styles.resultsContent}
-          keyboardShouldPersistTaps="always"
-          showsVerticalScrollIndicator={false}
-        >
-          {resultList}
-        </BottomSheetScrollView>
-      </IsolatedBottomSheetModal>
-    );
-  }
-
-  if (!open) return null;
-
-  // Desktop web: centered overlay panel
-  return (
-    <Modal visible={open} transparent animationType="fade" onRequestClose={handleClose}>
-      <View style={styles.overlay}>
-        <Pressable style={styles.backdrop} onPress={handleClose} />
-
-        <View testID="command-center-panel" style={panelStyle}>
-          <View style={headerStyle}>
-            <TextInput
-              testID="command-center-input"
-              ref={inputRef}
-              value={query}
-              onChangeText={setQuery}
-              placeholder={t("shell.commandCenter.placeholder")}
-              placeholderTextColor={theme.colors.foregroundMuted}
-              style={inputStyle}
-              autoCapitalize="none"
-              autoCorrect={false}
-              autoFocus
-            />
-          </View>
-
-          <ScrollView
-            ref={resultsRef}
-            style={styles.results}
-            contentContainerStyle={styles.resultsContent}
-            keyboardShouldPersistTaps="always"
-            showsVerticalScrollIndicator={false}
-          >
-            {resultList}
-          </ScrollView>
-        </View>
-      </View>
-    </Modal>
-  );
-}
-
-const styles = StyleSheet.create((theme) => ({
-  bottomSheetHeader: {
-    paddingHorizontal: theme.spacing[4],
-    paddingVertical: theme.spacing[3],
-    borderBottomWidth: 1,
-    borderBottomColor: theme.colors.border,
-  },
-  overlay: {
-    flex: 1,
-    justifyContent: "flex-start",
-    alignItems: "center",
-    paddingTop: theme.spacing[12],
-  },
-  backdrop: {
-    ...StyleSheet.absoluteFillObject,
-    backgroundColor: "rgba(0, 0, 0, 0.5)",
-  },
-  panel: {
-    width: 640,
-    maxWidth: "92%",
-    maxHeight: "80%",
-    borderWidth: 1,
-    borderRadius: theme.borderRadius.lg,
-    overflow: "hidden",
-    ...theme.shadow.lg,
-  },
-  header: {
-    paddingHorizontal: theme.spacing[4],
-    paddingVertical: theme.spacing[3],
-    borderBottomWidth: 1,
-  },
-  input: {
-    fontSize: theme.fontSize.base,
-    paddingVertical: theme.spacing[1],
-    outlineStyle: "none",
-  } as object,
-  results: {
-    flexGrow: 0,
-  },
-  resultsContent: {
-    paddingVertical: theme.spacing[2],
-  },
-  sectionLabel: {
-    paddingHorizontal: theme.spacing[4],
-    paddingTop: 0,
-    paddingBottom: theme.spacing[2],
-    fontSize: theme.fontSize.xs,
-  },
-  sectionDivider: {
-    height: 1,
-    marginTop: theme.spacing[2],
-    marginBottom: theme.spacing[2],
-  },
-  row: {
-    paddingHorizontal: theme.spacing[4],
-    paddingVertical: theme.spacing[2],
-  },
-  rowContent: {
-    flexDirection: "row",
-    alignItems: "center",
-    justifyContent: "space-between",
-    gap: theme.spacing[3],
-  },
-  rowMain: {
-    flex: 1,
-    minWidth: 0,
-    flexDirection: "row",
-    alignItems: "flex-start",
-    gap: theme.spacing[3],
-  },
-  iconSlot: {
-    width: 16,
-    height: 20,
-    alignItems: "center",
-    justifyContent: "center",
-  },
-  textContent: {
-    flex: 1,
-    minWidth: 0,
-    gap: 2,
-  },
-  rowShortcut: {
-    marginLeft: theme.spacing[2],
-    flexShrink: 0,
-  },
-  title: {
-    fontSize: theme.fontSize.sm,
-    fontWeight: "400",
-    lineHeight: 20,
-    color: theme.colors.foreground,
-  },
-  subtitle: {
-    fontSize: theme.fontSize.xs,
-    lineHeight: 18,
-    color: theme.colors.foregroundMuted,
-  },
-  emptyText: {
-    paddingHorizontal: theme.spacing[4],
-    paddingVertical: theme.spacing[4],
-    fontSize: theme.fontSize.base,
-  },
-}));
@@ -1,4 +1,4 @@
-import { buildWorkspaceTabPersistenceKey } from "@/stores/workspace-layout-store";
+import { buildWorkspaceTabPersistenceKey } from "@/workspace-tabs/model";
 import type { ActiveWorkspaceSelection } from "@/stores/navigation-active-workspace-store";
 import type { WorkspaceDescriptor } from "@/stores/session-store";

@@ -105,7 +105,7 @@ export function DictationControls({
          <Pressable
            onPress={onRetry}
            accessibilityLabel={t("message.dictation.retry")}
-            style={ACTION_CONFIRM_STYLE}
+            style={[styles.actionButton, styles.actionButtonConfirm]}
          >
            <RefreshCcw size={theme.iconSize.sm} color={theme.colors.surface0} />
          </Pressable>
@@ -115,14 +115,14 @@ export function DictationControls({
            <Pressable
              onPress={onAccept}
              accessibilityLabel={t("message.dictation.insert")}
-              style={ACTION_SECONDARY_STYLE}
+              style={[styles.actionButton, styles.actionButtonSecondary]}
            >
              <Check size={theme.iconSize.sm} color={theme.colors.foreground} />
            </Pressable>
            <Pressable
              onPress={onAcceptAndSend}
              accessibilityLabel={t("message.dictation.insertAndSend")}
-              style={ACTION_CONFIRM_STYLE}
+              style={[styles.actionButton, styles.actionButtonConfirm]}
            >
              <ArrowUp size={theme.iconSize.sm} color={theme.colors.surface0} />
            </Pressable>
@@ -240,7 +240,7 @@ export function DictationOverlay({
              onPress={onAccept}
              accessibilityRole="button"
              accessibilityLabel={t("message.dictation.insert")}
-              style={OVERLAY_ACCEPT_BUTTON_STYLE}
+              style={[overlayStyles.actionButton, OVERLAY_ACCEPT_BUTTON_BG]}
            >
              <Pencil
                size={theme.iconSize.lg}
@@ -400,7 +400,4 @@ const overlayStyles = StyleSheet.create((theme) => ({
  },
 }));

-const ACTION_CONFIRM_STYLE = [styles.actionButton, styles.actionButtonConfirm];
-const ACTION_SECONDARY_STYLE = [styles.actionButton, styles.actionButtonSecondary];
 const OVERLAY_ACCEPT_BUTTON_BG = { backgroundColor: "rgba(255, 255, 255, 0.25)" };
-const OVERLAY_ACCEPT_BUTTON_STYLE = [overlayStyles.actionButton, OVERLAY_ACCEPT_BUTTON_BG];
@@ -4,6 +4,7 @@ import { StyleSheet } from "react-native-unistyles";
 interface DiffStatProps {
  additions: number;
  deletions: number;
+  testID?: string;
 }

 const compactFormatter = new Intl.NumberFormat("en-US", {
@@ -15,9 +16,9 @@ export function formatDiffCount(value: number): string {
  return compactFormatter.format(value).toLowerCase();
 }

-export function DiffStat({ additions, deletions }: DiffStatProps) {
+export function DiffStat({ additions, deletions, testID }: DiffStatProps) {
  return (
-    <View style={styles.row}>
+    <View style={styles.row} testID={testID}>
      <Text style={styles.additions}>+{formatDiffCount(additions)}</Text>
      <Text style={styles.deletions}>-{formatDiffCount(deletions)}</Text>
    </View>
@@ -36,6 +36,11 @@ import { RetainedPanelActivity } from "@/components/retained-panel";
 import { SidebarResizeHandle } from "@/components/sidebar-resize-handle";
 import { buildWorkspaceAttachmentScopeKey } from "@/attachments/workspace-attachments-store";
 import { resolveDesktopExplorerWidth } from "@/components/desktop-sidebar-layout";
+import { useWorkspaceLayoutStore } from "@/stores/workspace-layout-store";
+import { buildWorkspaceTabPersistenceKey } from "@/workspace-tabs/model";
+import { resolveFocusedChatTarget } from "@/composer/focused-chat-target";
+import { createWorkspaceFileAttachment } from "@/attachments/workspace-file";
+import { useDraftStore } from "@/stores/draft-store";

 function logExplorerSidebar(_event: string, _details: Record<string, unknown>): void {}

@@ -211,7 +216,7 @@ export function ExplorerSidebar({

  return (
    <Animated.View style={desktopSidebarStyle}>
-      <View style={DESKTOP_SIDEBAR_BORDER_STYLE}>
+      <View style={[styles.desktopSidebarBorder, { flex: 1 }]}>
        <SidebarResizeHandle
          edge="left"
          gesture={resizeGesture}
@@ -386,15 +391,16 @@ function ExplorerSidebarContent({
      {/* Content based on active tab */}
      <View style={styles.contentArea} testID="explorer-content-area">
        {resolvedTab === "changes" && (
-          <GitDiffPane
+          <ChangedFilesPane
            serverId={serverId}
            workspaceId={workspaceId}
-            cwd={workspaceRoot}
-            enabled={isOpen}
+            workspaceRoot={workspaceRoot}
+            isOpen={isOpen}
+            onOpenFile={onOpenFile}
          />
        )}
        {resolvedTab === "files" && (
-          <FileExplorerPane
+          <FilesPane
            serverId={serverId}
            workspaceId={workspaceId}
            workspaceRoot={workspaceRoot}
@@ -415,6 +421,83 @@ function ExplorerSidebarContent({
  );
 }

+/**
+ * Shared add-to-chat state for the changes/files panes: both expose an "add file
+ * to chat" action that attaches the file to the focused chat's composer.
+ * Available only when a workspace with a focused chat is available.
+ */
+function useAddFileToChat({
+  serverId,
+  workspaceId,
+}: Pick<SidebarContentProps, "serverId" | "workspaceId">) {
+  const workspaceKey = workspaceId
+    ? buildWorkspaceTabPersistenceKey({ serverId, workspaceId })
+    : null;
+  const layout = useWorkspaceLayoutStore((state) =>
+    workspaceKey ? state.layoutByWorkspace[workspaceKey] : undefined,
+  );
+  const focusTab = useWorkspaceLayoutStore((state) => state.focusTab);
+  const focusedChat = useMemo(
+    () => resolveFocusedChatTarget({ serverId, layout }),
+    [serverId, layout],
+  );
+  const addFile = useCallback(
+    (filePath: string) => {
+      if (!focusedChat || !workspaceKey) {
+        return;
+      }
+      void useDraftStore.getState().attachWorkspaceFile({
+        draftKey: focusedChat.draftKey,
+        attachment: createWorkspaceFileAttachment({ path: filePath }),
+      });
+      focusTab(workspaceKey, focusedChat.tabId);
+    },
+    [focusTab, focusedChat, workspaceKey],
+  );
+  return { addFile, canAddToChat: focusedChat !== null };
+}
+
+function ChangedFilesPane({
+  serverId,
+  workspaceId,
+  workspaceRoot,
+  isOpen,
+  onOpenFile,
+}: Pick<
+  SidebarContentProps,
+  "serverId" | "workspaceId" | "workspaceRoot" | "isOpen" | "onOpenFile"
+>) {
+  const { addFile, canAddToChat } = useAddFileToChat({ serverId, workspaceId });
+  return (
+    <GitDiffPane
+      serverId={serverId}
+      workspaceId={workspaceId}
+      cwd={workspaceRoot}
+      enabled={isOpen}
+      onOpenFile={onOpenFile}
+      onAddToChat={canAddToChat ? addFile : undefined}
+    />
+  );
+}
+
+function FilesPane({
+  serverId,
+  workspaceId,
+  workspaceRoot,
+  onOpenFile,
+}: Pick<SidebarContentProps, "serverId" | "workspaceId" | "workspaceRoot" | "onOpenFile">) {
+  const { addFile, canAddToChat } = useAddFileToChat({ serverId, workspaceId });
+  return (
+    <FileExplorerPane
+      serverId={serverId}
+      workspaceId={workspaceId}
+      workspaceRoot={workspaceRoot}
+      onOpenFile={onOpenFile}
+      onAddToChat={canAddToChat ? addFile : undefined}
+    />
+  );
+}
+
 interface PrTabContentProps {
  serverId: string;
  cwd: string;
@@ -516,5 +599,3 @@ const styles = StyleSheet.create((theme) => ({
    minHeight: 0,
  },
 }));
-
-const DESKTOP_SIDEBAR_BORDER_STYLE = [styles.desktopSidebarBorder, { flex: 1 }];
@@ -0,0 +1,185 @@
+import { useMemo, type ReactElement, type ReactNode } from "react";
+import { type PressableStateCallbackType } from "react-native";
+import { StyleSheet, withUnistyles } from "react-native-unistyles";
+import {
+  Copy,
+  Download,
+  FileText,
+  MessageSquarePlus,
+  MoreVertical,
+  type LucideIcon,
+} from "lucide-react-native";
+import { useTranslation } from "react-i18next";
+import { ICON_SIZE, SPACING, type Theme } from "@/styles/theme";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+
+const foregroundMutedColorMapping = (theme: Theme) => ({ color: theme.colors.foregroundMuted });
+const ThemedMoreVertical = withUnistyles(MoreVertical);
+
+/** Width occupied by a file action trigger, including its visual padding. */
+export const FILE_ACTIONS_MENU_WIDTH = ICON_SIZE.sm + 2 * SPACING[1];
+
+interface FileAction {
+  key: string;
+  label: string;
+  icon: LucideIcon;
+  onSelect: () => void;
+  testID?: string;
+}
+
+interface FileActionsMenuProps {
+  fileKind: "file" | "directory";
+  fileExists?: boolean;
+  onOpenFile?: () => void;
+  onCopyPath?: () => void;
+  onDownload?: () => void;
+  onAddToChat?: () => void;
+  /** Optional metadata block rendered above the actions (e.g. size/modified). */
+  header?: ReactNode;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  hitSlop?: number;
+  accessibilityLabel: string;
+  testIDPrefix?: string;
+}
+
+// The menu lives inside pressable rows (diff header, explorer entry); stop the
+// press so opening it doesn't also trigger the row.
+function stopTriggerPropagation(event: { stopPropagation?: () => void }) {
+  event.stopPropagation?.();
+}
+
+function triggerStyle({
+  hovered,
+  pressed,
+  open,
+}: PressableStateCallbackType & { hovered?: boolean; open?: boolean }) {
+  return [styles.trigger, (Boolean(hovered) || pressed || Boolean(open)) && styles.triggerActive];
+}
+
+/**
+ * Shared kebab (⋮) menu for per-file actions. Used by the file explorer tree and
+ * git diff pane so both surfaces share action availability, ordering, and chrome.
+ */
+export function FileActionsMenu({
+  fileKind,
+  fileExists = true,
+  onOpenFile,
+  onCopyPath,
+  onDownload,
+  onAddToChat,
+  header,
+  open,
+  onOpenChange,
+  hitSlop = 12,
+  accessibilityLabel,
+  testIDPrefix,
+}: FileActionsMenuProps): ReactElement | null {
+  const { t } = useTranslation();
+  const actions = useMemo<FileAction[]>(() => {
+    const availableFile = fileKind === "file" && fileExists;
+    const next: FileAction[] = [];
+    if (availableFile && onOpenFile) {
+      next.push({
+        key: "open-file",
+        label: t("workspace.fileActions.openFile"),
+        icon: FileText,
+        onSelect: onOpenFile,
+        testID: testIDPrefix ? `${testIDPrefix}-open-file` : undefined,
+      });
+    }
+    if (onCopyPath) {
+      next.push({
+        key: "copy-path",
+        label: t("workspace.fileActions.copyPath"),
+        icon: Copy,
+        onSelect: onCopyPath,
+      });
+    }
+    if (availableFile && onDownload) {
+      next.push({
+        key: "download",
+        label: t("workspace.fileActions.download"),
+        icon: Download,
+        onSelect: onDownload,
+      });
+    }
+    if (availableFile && onAddToChat) {
+      next.push({
+        key: "add-to-chat",
+        label: t("workspace.fileActions.addToChat"),
+        icon: MessageSquarePlus,
+        onSelect: onAddToChat,
+        testID: testIDPrefix ? `${testIDPrefix}-add-to-chat` : undefined,
+      });
+    }
+    return next;
+  }, [fileExists, fileKind, onAddToChat, onCopyPath, onDownload, onOpenFile, t, testIDPrefix]);
+
+  if (actions.length === 0) {
+    return null;
+  }
+  return (
+    <DropdownMenu open={open} onOpenChange={onOpenChange}>
+      <DropdownMenuTrigger
+        hitSlop={hitSlop}
+        onPressIn={stopTriggerPropagation}
+        style={triggerStyle}
+        accessibilityLabel={accessibilityLabel}
+        testID={testIDPrefix ? `${testIDPrefix}-actions` : undefined}
+      >
+        <ThemedMoreVertical size={ICON_SIZE.sm} uniProps={foregroundMutedColorMapping} />
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" width={220}>
+        {header ? (
+          <>
+            {header}
+            <DropdownMenuSeparator />
+          </>
+        ) : null}
+        {actions.map((action) => (
+          <FileActionMenuItem key={action.key} action={action} />
+        ))}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
+
+function FileActionMenuItem({ action }: { action: FileAction }): ReactElement {
+  const Icon = action.icon;
+  const ThemedIcon = useMemo(() => withUnistyles(Icon), [Icon]);
+  const leading = useMemo(
+    () => <ThemedIcon size={ICON_SIZE.sm} uniProps={foregroundMutedColorMapping} />,
+    [ThemedIcon],
+  );
+  return (
+    <DropdownMenuItem leading={leading} onSelect={action.onSelect} testID={action.testID}>
+      {action.label}
+    </DropdownMenuItem>
+  );
+}
+
+const styles = StyleSheet.create((theme) => ({
+  trigger: {
+    // The hover box comes from padding, but an equal negative vertical margin
+    // cancels its height contribution so the trigger overlaps the row's natural
+    // line height instead of growing it. The comfortable tap target is `hitSlop`,
+    // never padding.
+    padding: theme.spacing[1],
+    width: FILE_ACTIONS_MENU_WIDTH,
+    marginVertical: -theme.spacing[1],
+    borderRadius: theme.borderRadius.md,
+    alignItems: "center",
+    justifyContent: "center",
+    flexShrink: 0,
+  },
+  triggerActive: {
+    backgroundColor: theme.colors.surface2,
+  },
+}));
@@ -1,4 +1,5 @@
 import type { ImageAttachment } from "@/composer/types";
+import type { WorkspaceFileDragPayload } from "@/attachments/workspace-file-drag";

 export interface DroppedFileItem {
  kind: "web-file";
@@ -18,4 +19,5 @@ export type DroppedItem = DroppedFileItem | DroppedPathItem;
 export interface FileDropSink {
  onFiles: (images: ImageAttachment[]) => void;
  onGenericFiles?: (items: DroppedItem[]) => void;
+  onWorkspaceFile?: (payload: WorkspaceFileDragPayload) => void;
 }
@@ -11,6 +11,10 @@ import {
 } from "@/attachments/file-types";
 import { isWeb } from "@/constants/platform";
 import type { DroppedItem, DroppedPathItem, FileDropSink } from "./types";
+import {
+  parseWorkspaceFileDragPayload,
+  WORKSPACE_FILE_DRAG_MIME,
+} from "@/attachments/workspace-file-drag";

 type DesktopDragDropPayload =
  | { type: "enter"; paths: string[] }
@@ -185,7 +189,11 @@ export function useDropListeners({
        if (disabledRef.current) return;

        dragCounter.current++;
-        if (e.dataTransfer?.types.includes("Files")) {
+        if (suppressed.value || !hasSink.value) return;
+        const types = new Set(e.dataTransfer?.types ?? []);
+        const acceptsWorkspaceFile =
+          types.has(WORKSPACE_FILE_DRAG_MIME) && Boolean(getSink()?.onWorkspaceFile);
+        if (types.has("Files") || acceptsWorkspaceFile) {
          isDragging.value = true;
        }
      }
@@ -197,7 +205,11 @@ export function useDropListeners({
        if (!e.dataTransfer) return;
        // Only advertise "copy" when the drop would actually be accepted, so the cursor doesn't
        // promise a drop that the handler then discards (suppressed/archived/no consumer mounted).
-        const canAccept = !disabledRef.current && !suppressed.value && hasSink.value;
+        const types = new Set(e.dataTransfer.types);
+        const acceptsWorkspaceFile =
+          types.has(WORKSPACE_FILE_DRAG_MIME) && Boolean(getSink()?.onWorkspaceFile);
+        const acceptsDrop = types.has("Files") || acceptsWorkspaceFile;
+        const canAccept = acceptsDrop && !disabledRef.current && !suppressed.value && hasSink.value;
        e.dataTransfer.dropEffect = canAccept ? "copy" : "none";
      }

@@ -225,6 +237,14 @@ export function useDropListeners({
        const sink = getSink();
        if (!sink) return;

+        const serializedWorkspaceFile = e.dataTransfer?.getData(WORKSPACE_FILE_DRAG_MIME);
+        if (serializedWorkspaceFile && sink.onWorkspaceFile) {
+          const payload = parseWorkspaceFileDragPayload(serializedWorkspaceFile);
+          if (payload) {
+            sink.onWorkspaceFile(payload);
+          }
+        }
+
        const files = Array.from(e.dataTransfer?.files ?? []);
        const genericItems: DroppedItem[] = files.map((file) => ({
          kind: "web-file",
@@ -15,36 +15,26 @@ import {
 import { StyleSheet, useUnistyles } from "react-native-unistyles";
 import { WORKSPACE_SECONDARY_HEADER_HEIGHT } from "@/constants/layout";
 import * as Clipboard from "expo-clipboard";
-import { SvgXml } from "react-native-svg";
+import { ChevronDown, Eye, EyeOff, RotateCw } from "lucide-react-native";
+import { MaterialFileIcon } from "@/components/material-file-icon";
 import {
-  ChevronDown,
-  Copy,
-  Download,
-  Eye,
-  EyeOff,
-  MoreVertical,
-  RotateCw,
-} from "lucide-react-native";
-import { getFileIconSvg } from "@/components/material-file-icons";
-import { TreeChevron, TreeIndentGuides, TREE_INDENT_PER_LEVEL } from "@/components/tree-primitives";
+  TreeChevron,
+  TreeIndentGuides,
+  treeRowPaddingLeft,
+  WORKSPACE_FILE_ROW_VERTICAL_PADDING,
+} from "@/components/tree-primitives";
 import { LoadingSpinner } from "@/components/ui/loading-spinner";
 import type { AgentFileExplorerState, ExplorerEntry } from "@/stores/session-store";
-import { useHosts } from "@/runtime/host-runtime";
 import { useSessionStore } from "@/stores/session-store";
-import { useDownloadStore } from "@/stores/download-store";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "@/components/ui/dropdown-menu";
+import { FileActionsMenu } from "@/components/file-actions-menu";
+import { useFileDownload } from "@/hooks/use-file-download";
 import { useFileExplorerActions } from "@/hooks/use-file-explorer-actions";
 import { buildWorkspaceExplorerStateKey } from "@/hooks/use-file-explorer-actions";
 import { usePanelStore, type SortOption } from "@/stores/panel-store";
 import { formatTimeAgo } from "@/utils/time";
 import { buildAbsoluteExplorerPath } from "@/utils/explorer-paths";
 import { filterVisibleExplorerEntries, isHiddenExplorerPath } from "@/file-explorer/visibility";
+import { useWorkspaceFileDragSource } from "@/attachments/use-workspace-file-drag-source";

 const SORT_OPTIONS: { value: SortOption }[] = [
  { value: "name" },
@@ -63,6 +53,8 @@ function formatFileSize({ size }: { size: number }): string {
 }

 interface TreeRowItemProps {
+  serverId: string;
+  workspaceId?: string | null;
  entry: ExplorerEntry;
  depth: number;
  isExpanded: boolean;
@@ -71,21 +63,8 @@ interface TreeRowItemProps {
  onEntryPress: (entry: ExplorerEntry) => void;
  onCopyPath: (path: string) => void;
  onDownloadEntry: (entry: ExplorerEntry) => void;
-}
-
-function stopPressInPropagation(event: { stopPropagation?: () => void }) {
-  event.stopPropagation?.();
-}
-
-function menuButtonStyle({
-  hovered,
-  pressed,
-  open,
-}: PressableStateCallbackType & { hovered?: boolean; open?: boolean }) {
-  return [
-    styles.menuButton,
-    (Boolean(hovered) || pressed || Boolean(open)) && styles.menuButtonActive,
-  ];
+  onAddToChat?: (path: string) => void;
+  testID?: string;
 }

 function sortTriggerStyle({
@@ -104,6 +83,8 @@ function treeRowKeyExtractor(row: TreeRow) {
 }

 function TreeRowItem({
+  serverId,
+  workspaceId,
  entry,
  depth,
  isExpanded,
@@ -112,10 +93,17 @@ function TreeRowItem({
  onEntryPress,
  onCopyPath,
  onDownloadEntry,
+  onAddToChat,
+  testID,
 }: TreeRowItemProps) {
-  const { theme } = useUnistyles();
  const { t } = useTranslation();
  const isDirectory = entry.kind === "directory";
+  const dragSourceRef = useWorkspaceFileDragSource({
+    enabled: !isDirectory,
+    serverId,
+    workspaceId,
+    path: entry.path,
+  });

  const handlePress = useCallback(() => {
    onEntryPress(entry);
@@ -124,10 +112,10 @@ function TreeRowItem({
  const pressableStyle = useCallback(
    ({ hovered, pressed }: PressableStateCallbackType & { hovered?: boolean }) => [
      styles.entryRow,
-      { paddingLeft: theme.spacing[2] + depth * TREE_INDENT_PER_LEVEL },
+      { paddingLeft: treeRowPaddingLeft(depth) },
      (Boolean(hovered) || pressed || isSelected) && styles.entryRowActive,
    ],
-    [depth, isSelected, theme.spacing],
+    [depth, isSelected],
  );

  const handleCopy = useCallback(() => {
@@ -138,23 +126,42 @@ function TreeRowItem({
    onDownloadEntry(entry);
  }, [onDownloadEntry, entry]);

-  const copyLeading = useMemo(
-    () => <Copy size={14} color={theme.colors.foregroundMuted} />,
-    [theme.colors.foregroundMuted],
-  );
-  const downloadLeading = useMemo(
-    () => <Download size={14} color={theme.colors.foregroundMuted} />,
-    [theme.colors.foregroundMuted],
+  const handleAddToChat = useCallback(() => {
+    onAddToChat?.(entry.path);
+  }, [onAddToChat, entry.path]);
+
+  const metaHeader = useMemo(
+    () => (
+      <View style={styles.contextMetaBlock}>
+        <View style={styles.contextMetaRow}>
+          <Text style={styles.contextMetaLabel} numberOfLines={1}>
+            {t("workspace.fileExplorer.context.size")}
+          </Text>
+          <Text style={styles.contextMetaValue} numberOfLines={1} ellipsizeMode="tail">
+            {formatFileSize({ size: entry.size })}
+          </Text>
+        </View>
+        <View style={styles.contextMetaRow}>
+          <Text style={styles.contextMetaLabel} numberOfLines={1}>
+            {t("workspace.fileExplorer.context.modified")}
+          </Text>
+          <Text style={styles.contextMetaValue} numberOfLines={1} ellipsizeMode="tail">
+            {formatTimeAgo(new Date(entry.modifiedAt))}
+          </Text>
+        </View>
+      </View>
+    ),
+    [entry.modifiedAt, entry.size, t],
  );

  return (
-    <Pressable onPress={handlePress} style={pressableStyle}>
+    <Pressable onPress={handlePress} style={pressableStyle} testID={testID}>
      <TreeIndentGuides depth={depth} />
-      <View style={styles.entryInfo}>
+      <View ref={dragSourceRef} style={styles.entryInfo}>
        <View style={styles.entryIcon}>
          {(() => {
            if (!isDirectory) {
-              return <SvgXml xml={getFileIconSvg(entry.name)} width={16} height={16} />;
+              return <MaterialFileIcon fileName={entry.name} size={16} />;
            }
            if (loading) return <ActivityIndicator size="small" />;
            return <TreeChevron expanded={isExpanded} />;
@@ -164,40 +171,15 @@ function TreeRowItem({
          {entry.name}
        </Text>
      </View>
-      <DropdownMenu>
-        <DropdownMenuTrigger hitSlop={8} onPressIn={stopPressInPropagation} style={menuButtonStyle}>
-          <MoreVertical size={16} color={theme.colors.foregroundMuted} />
-        </DropdownMenuTrigger>
-        <DropdownMenuContent align="end" width={220}>
-          <View style={styles.contextMetaBlock}>
-            <View style={styles.contextMetaRow}>
-              <Text style={styles.contextMetaLabel} numberOfLines={1}>
-                {t("workspace.fileExplorer.context.size")}
-              </Text>
-              <Text style={styles.contextMetaValue} numberOfLines={1} ellipsizeMode="tail">
-                {formatFileSize({ size: entry.size })}
-              </Text>
-            </View>
-            <View style={styles.contextMetaRow}>
-              <Text style={styles.contextMetaLabel} numberOfLines={1}>
-                {t("workspace.fileExplorer.context.modified")}
-              </Text>
-              <Text style={styles.contextMetaValue} numberOfLines={1} ellipsizeMode="tail">
-                {formatTimeAgo(new Date(entry.modifiedAt))}
-              </Text>
-            </View>
-          </View>
-          <DropdownMenuSeparator />
-          <DropdownMenuItem leading={copyLeading} onSelect={handleCopy}>
-            {t("workspace.fileExplorer.context.copyPath")}
-          </DropdownMenuItem>
-          {entry.kind === "file" ? (
-            <DropdownMenuItem leading={downloadLeading} onSelect={handleDownload}>
-              {t("workspace.fileExplorer.context.download")}
-            </DropdownMenuItem>
-          ) : null}
-        </DropdownMenuContent>
-      </DropdownMenu>
+      <FileActionsMenu
+        fileKind={entry.kind}
+        onCopyPath={handleCopy}
+        onDownload={handleDownload}
+        onAddToChat={onAddToChat ? handleAddToChat : undefined}
+        header={metaHeader}
+        accessibilityLabel={t("workspace.fileActions.moreActions")}
+        testIDPrefix={testID}
+      />
    </Pressable>
  );
 }
@@ -207,6 +189,7 @@ interface FileExplorerPaneProps {
  workspaceId?: string | null;
  workspaceRoot: string;
  onOpenFile?: (filePath: string) => void;
+  onAddToChat?: (path: string) => void;
 }

 interface TreeRow {
@@ -219,14 +202,10 @@ export function FileExplorerPane({
  workspaceId,
  workspaceRoot,
  onOpenFile,
+  onAddToChat,
 }: FileExplorerPaneProps) {
  const { t } = useTranslation();

-  const daemons = useHosts();
-  const daemonProfile = useMemo(
-    () => daemons.find((daemon) => daemon.serverId === serverId),
-    [daemons, serverId],
-  );
  const normalizedWorkspaceRoot = useMemo(() => workspaceRoot.trim(), [workspaceRoot]);
  const workspaceStateKey = useMemo(
    () =>
@@ -236,10 +215,6 @@ export function FileExplorerPane({
      }),
    [normalizedWorkspaceRoot, workspaceId],
  );
-  const workspaceScopeId = useMemo(
-    () => workspaceId?.trim() || normalizedWorkspaceRoot,
-    [normalizedWorkspaceRoot, workspaceId],
-  );
  const hasWorkspaceScope = Boolean(workspaceStateKey && normalizedWorkspaceRoot);
  const explorerState = useSessionStore((state) =>
    workspaceStateKey && state.sessions[serverId]
@@ -247,12 +222,16 @@ export function FileExplorerPane({
      : undefined,
  );

-  const { requestDirectoryListing, requestFileDownloadToken, selectExplorerEntry } =
-    useFileExplorerActions({
-      serverId,
-      workspaceId,
-      workspaceRoot: normalizedWorkspaceRoot,
-    });
+  const { requestDirectoryListing, selectExplorerEntry } = useFileExplorerActions({
+    serverId,
+    workspaceId,
+    workspaceRoot: normalizedWorkspaceRoot,
+  });
+  const downloadFile = useFileDownload({
+    serverId,
+    workspaceId,
+    workspaceRoot: normalizedWorkspaceRoot,
+  });
  const sortOption = usePanelStore((state) => state.explorerSortOption);
  const showHiddenFiles = usePanelStore((state) => state.explorerShowHiddenFiles);
  const setSortOption = usePanelStore((state) => state.setExplorerSortOption);
@@ -347,18 +326,14 @@ export function FileExplorerPane({
    [normalizedWorkspaceRoot],
  );

-  const startDownload = useDownloadStore((state) => state.startDownload);
  const handleDownloadEntry = useCallback(
-    (entry: ExplorerEntry) =>
-      downloadExplorerEntry({
-        entry,
-        workspaceScopeId,
-        serverId,
-        daemonProfile,
-        startDownload,
-        requestFileDownloadToken,
-      }),
-    [daemonProfile, requestFileDownloadToken, serverId, startDownload, workspaceScopeId],
+    (entry: ExplorerEntry) => {
+      if (entry.kind !== "file") {
+        return;
+      }
+      downloadFile({ fileName: entry.name, path: entry.path });
+    },
+    [downloadFile],
  );

  const handleSortCycle = useCallback(() => {
@@ -420,6 +395,8 @@ export function FileExplorerPane({
  const renderTreeRow = useCallback(
    (info: ListRenderItemInfo<TreeRow>) => (
      <TreeRowDispatcher
+        serverId={serverId}
+        workspaceId={workspaceId}
        info={info}
        expandedPaths={expandedPaths}
        selectedEntryPath={selectedEntryPath}
@@ -427,6 +404,7 @@ export function FileExplorerPane({
        onEntryPress={handleEntryPress}
        onCopyPath={handleCopyPath}
        onDownloadEntry={handleDownloadEntry}
+        onAddToChat={onAddToChat}
      />
    ),
    [
@@ -436,6 +414,9 @@ export function FileExplorerPane({
      handleDownloadEntry,
      isDirectoryLoading,
      selectedEntryPath,
+      onAddToChat,
+      serverId,
+      workspaceId,
    ],
  );

@@ -575,10 +556,16 @@ function FileExplorerPaneContent(props: FileExplorerPaneContentProps) {
  }

  return (
-    <View style={TREE_PANE_CONTAINER_STYLE}>
+    <View style={[styles.treePane, styles.treePaneFill]}>
      <View style={styles.paneHeader} testID="files-pane-header">
-        <Pressable onPress={handleSortCycle} style={sortTriggerStyleProp}>
-          <Text style={styles.sortTriggerText}>{currentSortLabel}</Text>
+        <Pressable
+          onPress={handleSortCycle}
+          style={sortTriggerStyleProp}
+          testID="files-sort-trigger"
+        >
+          <Text style={styles.sortTriggerText} testID="files-sort-label">
+            {currentSortLabel}
+          </Text>
          <ChevronDown size={12} color={theme.colors.foregroundMuted} />
        </Pressable>
        <View style={styles.headerActions}>
@@ -589,6 +576,7 @@ function FileExplorerPaneContent(props: FileExplorerPaneContentProps) {
            accessibilityRole="button"
            accessibilityLabel={hiddenFilesToggleAccessibilityLabel}
            accessibilityState={hiddenFilesToggleAccessibilityState}
+            testID="files-hidden-toggle"
          >
            {showHiddenFiles ? (
              <Eye size={theme.iconSize.sm} color={theme.colors.foregroundMuted} />
@@ -607,6 +595,7 @@ function FileExplorerPaneContent(props: FileExplorerPaneContentProps) {
                ? t("workspace.fileExplorer.actions.refreshing")
                : t("workspace.fileExplorer.actions.refresh")
            }
+            testID="files-refresh"
          >
            <View style={styles.refreshIcon}>
              {isRefreshFetching ? (
@@ -779,39 +768,6 @@ function resolveTreeRows({
  });
 }

-type StartDownloadFn = ReturnType<typeof useDownloadStore.getState>["startDownload"];
-type StartDownloadParams = Parameters<StartDownloadFn>[0];
-
-function downloadExplorerEntry({
-  entry,
-  workspaceScopeId,
-  serverId,
-  daemonProfile,
-  startDownload,
-  requestFileDownloadToken,
-}: {
-  entry: ExplorerEntry;
-  workspaceScopeId: string | undefined;
-  serverId: string;
-  daemonProfile: StartDownloadParams["daemonProfile"];
-  startDownload: StartDownloadFn;
-  requestFileDownloadToken: (
-    targetPath: string,
-  ) => ReturnType<StartDownloadParams["requestFileDownloadToken"]>;
-}): void {
-  if (!workspaceScopeId || entry.kind !== "file") {
-    return;
-  }
-  startDownload({
-    serverId,
-    scopeId: workspaceScopeId,
-    fileName: entry.name,
-    path: entry.path,
-    daemonProfile,
-    requestFileDownloadToken: (targetPath) => requestFileDownloadToken(targetPath),
-  });
-}
-
 function toggleDirectory({
  entry,
  workspaceStateKey,
@@ -851,6 +807,8 @@ function toggleDirectory({
 }

 function TreeRowDispatcher({
+  serverId,
+  workspaceId,
  info,
  expandedPaths,
  selectedEntryPath,
@@ -858,7 +816,10 @@ function TreeRowDispatcher({
  onEntryPress,
  onCopyPath,
  onDownloadEntry,
+  onAddToChat,
 }: {
+  serverId: string;
+  workspaceId?: string | null;
  info: ListRenderItemInfo<TreeRow>;
  expandedPaths: Set<string>;
  selectedEntryPath: string | null;
@@ -866,6 +827,7 @@ function TreeRowDispatcher({
  onEntryPress: (entry: ExplorerEntry) => void;
  onCopyPath: (path: string) => void | Promise<void>;
  onDownloadEntry: (entry: ExplorerEntry) => void;
+  onAddToChat?: (path: string) => void;
 }) {
  const entry = info.item.entry;
  const depth = info.item.depth;
@@ -876,6 +838,8 @@ function TreeRowDispatcher({

  return (
    <TreeRowItem
+      serverId={serverId}
+      workspaceId={workspaceId}
      entry={entry}
      depth={depth}
      isExpanded={isExpanded}
@@ -884,6 +848,8 @@ function TreeRowDispatcher({
      onEntryPress={onEntryPress}
      onCopyPath={onCopyPath}
      onDownloadEntry={onDownloadEntry}
+      onAddToChat={onAddToChat}
+      testID={`file-explorer-row-${info.index}`}
    />
  );
 }
@@ -1062,7 +1028,6 @@ const styles = StyleSheet.create((theme) => ({
    minHeight: 0,
  },
  entriesContent: {
-    paddingHorizontal: theme.spacing[2],
    paddingTop: theme.spacing[2],
    paddingBottom: theme.spacing[4],
  },
@@ -1112,9 +1077,8 @@ const styles = StyleSheet.create((theme) => ({
    flexDirection: "row",
    alignItems: "center",
    justifyContent: "space-between",
-    paddingVertical: 2,
-    paddingRight: theme.spacing[2],
-    borderRadius: theme.borderRadius.md,
+    paddingVertical: WORKSPACE_FILE_ROW_VERTICAL_PADDING,
+    paddingRight: theme.spacing[3],
  },
  entryRowActive: {
    backgroundColor: theme.colors.surfaceSidebarHover,
@@ -1134,16 +1098,6 @@ const styles = StyleSheet.create((theme) => ({
    color: theme.colors.foreground,
    fontSize: theme.fontSize.sm,
  },
-  menuButton: {
-    width: 30,
-    height: 30,
-    borderRadius: theme.borderRadius.full,
-    alignItems: "center",
-    justifyContent: "center",
-  },
-  menuButtonActive: {
-    backgroundColor: theme.colors.surface2,
-  },
  contextMetaBlock: {
    paddingVertical: theme.spacing[1],
  },
@@ -1253,5 +1207,3 @@ const styles = StyleSheet.create((theme) => ({
    padding: theme.spacing[4],
  },
 }));
-
-const TREE_PANE_CONTAINER_STYLE = [styles.treePane, styles.treePaneFill];
--- a/Show More
+++ b/Show More