chore(release): cut 0.1.53

Add missing lastEmittedByWorkspaceId to test subscription stubs,
update activityAt assertion to null, and adjust dedup test to expect
deduplicated emissions.

.github/FUNDING.yml

@@ -0,0 +1,15 @@
+# These are supported funding model platforms
+
+github: [boudra]
+patreon: # Replace with a single Patreon username
+open_collective: # Replace with a single Open Collective username
+ko_fi: # Replace with a single Ko-fi username
+tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+liberapay: # Replace with a single Liberapay username
+issuehunt: # Replace with a single IssueHunt username
+lfx_crowdfunding: # Replace with a single LFX Crowdfunding project-name e.g., cloud-foundry
+polar: # Replace with a single Polar username
+buy_me_a_coffee: # Replace with a single Buy Me a Coffee username
+thanks_dev: # Replace with a single thanks.dev username
+custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']

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

@@ -4,6 +4,7 @@ on:
   push:
     tags:
       - "v*"
+      - "android-v*"
   workflow_dispatch:
     inputs:
       tag:
@@ -16,7 +17,7 @@ concurrency:
   cancel-in-progress: false
 
 env:
-  RELEASE_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref_name }}
+  SOURCE_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref_name }}
 
 jobs:
   publish-android-apk:
@@ -31,6 +32,36 @@ jobs:
           fetch-depth: 0
           ref: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref }}
 
+      - name: Resolve release tag
+        shell: bash
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
+
+      - name: Ensure GitHub release exists
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          if gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" >/dev/null 2>&1; then
+            exit 0
+          fi
+
+          release_args=(
+            release create "$RELEASE_TAG"
+            --repo "${{ github.repository }}"
+            --title "Paseo $RELEASE_TAG"
+            --generate-notes
+          )
+
+          if [[ "$IS_PRERELEASE" == "true" ]]; then
+            release_args+=(--prerelease)
+          fi
+
+          if ! gh "${release_args[@]}"; then
+            echo "Release creation raced with another workflow; continuing."
+          fi
+
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
@@ -94,24 +125,6 @@ jobs:
           echo "asset_name=$asset_name" >> "$GITHUB_OUTPUT"
           echo "asset_path=$asset_path" >> "$GITHUB_OUTPUT"
 
-      - name: Wait for GitHub release tag
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          for attempt in $(seq 1 90); do
-            if gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" >/dev/null 2>&1; then
-              echo "Found release for tag $RELEASE_TAG"
-              exit 0
-            fi
-            echo "Release for $RELEASE_TAG is not available yet (attempt $attempt/90)."
-            sleep 20
-          done
-
-          echo "Timed out waiting for GitHub release tag $RELEASE_TAG."
-          exit 1
-
       - name: Upload APK to GitHub Release
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci.yml

@@ -0,0 +1,184 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Check formatting
+        run: npx biome format .
+
+  typecheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
+      - name: Build relay dependency
+        run: npm run build --workspace=@getpaseo/relay
+
+      - name: Typecheck all packages
+        run: npm run typecheck
+
+  server-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Fetch origin/main (worktree tests)
+        run: git fetch --no-tags origin main:refs/remotes/origin/main
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
+      - name: Build relay dependency
+        run: npm run build --workspace=@getpaseo/relay
+
+      - name: Run server tests
+        run: npm run test --workspace=@getpaseo/server
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+  app-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
+      - name: Run app unit tests
+        run: npm run test --workspace=@getpaseo/app
+
+  playwright:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps chromium
+
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
+      - name: Build relay dependency
+        run: npm run build --workspace=@getpaseo/relay
+
+      - name: Build server dependency
+        run: npm run build --workspace=@getpaseo/server
+
+      - name: Install agent CLIs for provider tests
+        run: npm install -g @openai/codex@0.105.0 opencode-ai
+
+      - name: Run Playwright E2E tests
+        run: npm run test:e2e --workspace=@getpaseo/app
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+      - name: Upload test artifacts
+        uses: actions/upload-artifact@v4
+        if: failure()
+        with:
+          name: playwright-results
+          path: |
+            packages/app/test-results/
+            packages/app/playwright-report/
+          retention-days: 7
+
+  relay-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Build relay
+        run: npm run build --workspace=@getpaseo/relay
+
+      - name: Run relay tests
+        run: npm run test --workspace=@getpaseo/relay
+
+  cli-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Install agent CLIs for provider tests
+        run: npm install -g @openai/codex@0.105.0 opencode-ai
+
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
+      - name: Run CLI tests
+        run: npm run test --workspace=@getpaseo/cli
+        env:
+          PASEO_LOCAL_SPEECH_AUTO_DOWNLOAD: '0'
+          PASEO_DICTATION_ENABLED: '0'
+          PASEO_VOICE_MODE_ENABLED: '0'

.github/workflows/deploy-app.yml

@@ -4,6 +4,9 @@ on:
   push:
     tags:
       - 'v*'
+      - '!v*-rc.*'
+      - 'app-v*'
+      - '!app-v*-rc.*'
   workflow_dispatch:
 
 jobs:
@@ -25,6 +28,9 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
       - name: Typecheck
         run: npm run typecheck --workspace=@getpaseo/app
 

.github/workflows/deploy-website.yml

@@ -9,10 +9,13 @@ on:
       - 'package-lock.json'
       - 'patches/**'
       - '.github/workflows/deploy-website.yml'
+  release:
+    types: [published, edited]
   workflow_dispatch:
 
 jobs:
   deploy:
+    if: ${{ github.event_name != 'release' || (!github.event.release.prerelease && !github.event.release.draft) }}
     runs-on: ubuntu-latest
 
     steps:

.github/workflows/desktop-release.yml

@@ -3,21 +3,21 @@ name: Desktop Release
 on:
   push:
     tags:
-      - "v*"
-      - "desktop-v*"
-      - "desktop-macos-v*"
-      - "desktop-linux-v*"
-      - "desktop-windows-v*"
+      - 'v*'
+      - 'desktop-v*'
+      - 'desktop-macos-v*'
+      - 'desktop-linux-v*'
+      - 'desktop-windows-v*'
   workflow_dispatch:
     inputs:
       tag:
-        description: "Existing tag to build (e.g. v0.1.0)"
+        description: 'Existing tag to build (e.g. v0.1.0)'
         required: true
         type: string
       platform:
-        description: "Optional desktop platform to build."
+        description: 'Optional desktop platform to build.'
         required: false
-        default: "all"
+        default: 'all'
         type: choice
         options:
           - all
@@ -31,18 +31,55 @@ concurrency:
 
 env:
   SOURCE_TAG: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref_name }}
+  DESKTOP_WORKSPACE: '@getpaseo/desktop'
+  DESKTOP_PACKAGE_PATH: 'packages/desktop'
 
 jobs:
+  create-release:
+    if: ${{ (github.event_name == 'push' && !startsWith(github.ref_name, 'desktop-macos-v') && !startsWith(github.ref_name, 'desktop-linux-v') && !startsWith(github.ref_name, 'desktop-windows-v')) || (github.event_name == 'workflow_dispatch' && github.event.inputs.platform == 'all') }}
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          sparse-checkout: scripts
+          ref: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref }}
+
+      - name: Resolve release metadata
+        shell: bash
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
+
+      - name: Create GitHub release
+        if: env.IS_SMOKE_TAG != 'true'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          if gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" > /dev/null 2>&1; then
+            echo "Release $RELEASE_TAG already exists, skipping creation"
+          else
+            prerelease_flag=""
+            if [[ "$IS_PRERELEASE" == "true" ]]; then
+              prerelease_flag="--prerelease"
+            fi
+            gh release create "$RELEASE_TAG" \
+              --repo "${{ github.repository }}" \
+              --title "Paseo $RELEASE_TAG" \
+              --generate-notes \
+              $prerelease_flag
+          fi
+
   publish-macos:
-    if: ${{ (github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'macos')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-macos-v'))) }}
+    needs: [create-release]
+    if: ${{ always() && (needs.create-release.result == 'success' || needs.create-release.result == 'skipped') && ((github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'macos')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-macos-v')))) }}
     strategy:
       fail-fast: false
       matrix:
         include:
           - runner: macos-14
-            rust_target: aarch64-apple-darwin
+            electron_arch: arm64
           - runner: macos-15-intel
-            rust_target: x86_64-apple-darwin
+            electron_arch: x64
     permissions:
       contents: write
       packages: read
@@ -56,185 +93,169 @@ jobs:
 
       - name: Resolve release metadata
         shell: bash
-        run: |
-          set -euo pipefail
-          source_tag="${SOURCE_TAG}"
-          if [[ "$source_tag" =~ ^(desktop-(windows|linux|macos)-|desktop-)?v([0-9]+\.[0-9]+\.[0-9]+) ]]; then
-            release_tag="v${BASH_REMATCH[3]}"
-          else
-            release_tag="$source_tag"
-          fi
-          echo "RELEASE_TAG=$release_tag" >> "$GITHUB_ENV"
-
-          version="${release_tag#v}"
-          echo "DESKTOP_VERSION=$version" >> "$GITHUB_ENV"
-
-          if [[ "$source_tag" == *gha-smoke* ]]; then
-            echo "IS_SMOKE_TAG=true" >> "$GITHUB_ENV"
-          else
-            echo "IS_SMOKE_TAG=false" >> "$GITHUB_ENV"
-          fi
-
-      - name: Set desktop version from tag
-        shell: bash
-        run: |
-          node <<'NODE'
-          const fs = require('node:fs');
-          const path = require('node:path');
-          const version = process.env.DESKTOP_VERSION;
-          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
-          console.log(`Setting desktop version to ${version}`);
-
-          const tauriConfPath = path.join('packages', 'desktop', 'src-tauri', 'tauri.conf.json');
-          const tauriConfText = fs.readFileSync(tauriConfPath, 'utf8');
-          const tauriRe = /("version"\s*:\s*")([^"]+)(")/;
-          if (!tauriRe.test(tauriConfText)) throw new Error('Failed to find version in tauri.conf.json');
-          fs.writeFileSync(tauriConfPath, tauriConfText.replace(tauriRe, `$1${version}$3`));
-
-          const cargoTomlPath = path.join('packages', 'desktop', 'src-tauri', 'Cargo.toml');
-          const lines = fs.readFileSync(cargoTomlPath, 'utf8').split(/\r?\n/);
-          let inPackage = false, updated = false;
-          const result = lines.map((line) => {
-            if (/^\[package\]\s*$/.test(line)) inPackage = true;
-            else if (inPackage && /^\[/.test(line)) inPackage = false;
-            if (inPackage && /^version\s*=\s*".*"\s*$/.test(line)) {
-              updated = true;
-              return `version = "${version}"`;
-            }
-            return line;
-          });
-          if (!updated) throw new Error('Failed to update Cargo.toml version');
-          fs.writeFileSync(cargoTomlPath, result.join('\n') + '\n');
-          NODE
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
 
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
-          cache: "npm"
+          node-version: '22'
+          cache: 'npm'
           cache-dependency-path: package-lock.json
-          registry-url: "https://npm.pkg.github.com"
-          scope: "@boudra"
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-        with:
-          targets: ${{ matrix.rust_target }}
-
-      - name: Restore Rust cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: desktop-release-macos-${{ matrix.rust_target }}
-          workspaces: |
-            .
-            packages/desktop/src-tauri -> target
+          registry-url: 'https://npm.pkg.github.com'
+          scope: '@boudra'
 
       - name: Install JS dependencies
         run: npm ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build web app for Tauri
+      - name: Set desktop package version from tag
+        shell: bash
+        run: |
+          node <<'NODE'
+          const fs = require('node:fs');
+          const path = require('node:path');
+
+          const version = process.env.DESKTOP_VERSION;
+          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
+
+          const packageJsonPath = path.join(process.env.DESKTOP_PACKAGE_PATH, 'package.json');
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+          packageJson.version = version;
+          fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+          NODE
+
+      - name: Build web app for desktop
         run: npm run build:web --workspace=@getpaseo/app
 
-      - name: Build managed runtime
-        run: npm run prepare:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Validate managed runtime bundle
-        run: npm run validate:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Import Apple code-signing certificate
-        uses: apple-actions/import-codesign-certs@v3
-        with:
-          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
-          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-
-      - name: Sign bundled managed runtime
-        env:
-          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
-        run: node ./packages/desktop/scripts/sign-managed-runtime-macos.mjs
-
-      - name: Detect existing GitHub release state
-        if: env.IS_SMOKE_TAG != 'true'
+      - name: Build desktop release
+        shell: bash
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          EP_GH_IGNORE_TIME: true
+          CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
+          CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
+          APPLE_ID: ${{ secrets.APPLE_ID }}
+          APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
+          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+        run: |
+          set -euo pipefail
+          publish_mode="never"
+          publish_args=()
+          if [[ "$IS_SMOKE_TAG" != "true" ]]; then
+            publish_mode="always"
+            publish_args+=("-c.publish.releaseType=$RELEASE_TYPE")
+          fi
+
+          npm run build --workspace="$DESKTOP_WORKSPACE" -- --publish "$publish_mode" --mac --${{ matrix.electron_arch }} "${publish_args[@]}"
+
+      - name: Upload manifest artifact
+        if: env.IS_SMOKE_TAG != 'true'
+        uses: actions/upload-artifact@v4
+        with:
+          name: mac-manifest-${{ matrix.electron_arch }}
+          path: ${{ env.DESKTOP_PACKAGE_PATH }}/release/latest-mac.yml
+          retention-days: 1
+
+  finalize-mac-manifest:
+    needs: [publish-macos]
+    if: ${{ needs.publish-macos.result == 'success' }}
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          sparse-checkout: scripts
+          ref: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref }}
+
+      - name: Resolve release tag
+        shell: bash
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
+
+      - name: Download manifest artifacts
+        if: env.IS_SMOKE_TAG != 'true'
+        uses: actions/download-artifact@v4
+        with:
+          pattern: mac-manifest-*
+
+      - name: Merge manifests
+        if: env.IS_SMOKE_TAG != 'true'
         shell: bash
         run: |
           set -euo pipefail
-          if release_draft="$(gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" --json isDraft --jq '.isDraft' 2>/dev/null)"; then
-            :
-          else
-            release_draft="false"
-          fi
-          echo "RELEASE_DRAFT=$release_draft" >> "$GITHUB_ENV"
 
-      - name: Build and publish macOS Tauri release
-        if: env.IS_SMOKE_TAG != 'true'
-        id: tauri_build
-        uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          APPLE_CERTIFICATE: ${{ secrets.APPLE_CERTIFICATE }}
-          APPLE_CERTIFICATE_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        with:
-          projectPath: packages/desktop
-          tagName: ${{ env.RELEASE_TAG }}
-          releaseName: Paseo ${{ env.RELEASE_TAG }}
-          releaseBody: See the assets to download and install this version.
-          releaseDraft: ${{ env.RELEASE_DRAFT }}
-          prerelease: false
-          args: --target ${{ matrix.rust_target }}
+          node <<'NODE'
+          const fs = require('node:fs');
 
-      - name: Notarize and re-upload DMG
+          // Simple YAML parser for electron-builder's latest-mac.yml format
+          function parseManifest(text) {
+            const lines = text.split('\n');
+            const result = { files: [] };
+            let currentFile = null;
+
+            for (const line of lines) {
+              if (line.startsWith('version:')) result.version = line.split(': ')[1].trim();
+              else if (line.startsWith('path:')) result.path = line.split(': ')[1].trim();
+              else if (line.startsWith('sha512:') && !currentFile) result.sha512 = line.split(': ')[1].trim();
+              else if (line.startsWith('releaseDate:')) result.releaseDate = line.split(': ')[1].trim().replace(/'/g, '');
+              else if (line.trim().startsWith('- url:')) {
+                currentFile = { url: line.trim().replace('- url: ', '') };
+                result.files.push(currentFile);
+              } else if (line.trim().startsWith('sha512:') && currentFile) {
+                currentFile.sha512 = line.trim().split(': ')[1].trim();
+              } else if (line.trim().startsWith('size:') && currentFile) {
+                currentFile.size = parseInt(line.trim().split(': ')[1].trim(), 10);
+                currentFile = null;
+              }
+            }
+            return result;
+          }
+
+          function toYaml(manifest) {
+            let out = `version: ${manifest.version}\n`;
+            out += `files:\n`;
+            for (const f of manifest.files) {
+              out += `  - url: ${f.url}\n`;
+              out += `    sha512: ${f.sha512}\n`;
+              out += `    size: ${f.size}\n`;
+            }
+            out += `path: ${manifest.path}\n`;
+            out += `sha512: ${manifest.sha512}\n`;
+            out += `releaseDate: '${manifest.releaseDate}'\n`;
+            return out;
+          }
+
+          const arm64Text = fs.readFileSync('mac-manifest-arm64/latest-mac.yml', 'utf8');
+          const x64Text = fs.readFileSync('mac-manifest-x64/latest-mac.yml', 'utf8');
+
+          const arm64 = parseManifest(arm64Text);
+          const x64 = parseManifest(x64Text);
+
+          // Merge: all files from both, default path points to arm64 zip
+          const merged = {
+            version: arm64.version,
+            files: [...arm64.files, ...x64.files],
+            path: arm64.path,
+            sha512: arm64.sha512,
+            releaseDate: arm64.releaseDate || x64.releaseDate,
+          };
+
+          const output = toYaml(merged);
+          fs.writeFileSync('latest-mac.yml', output);
+          console.log('Merged manifest:\n' + output);
+          NODE
+
+      - name: Upload merged manifest to release
         if: env.IS_SMOKE_TAG != 'true'
         env:
-          APPLE_ID: ${{ secrets.APPLE_ID }}
-          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
-          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
-          APPLE_SIGNING_IDENTITY: ${{ secrets.APPLE_SIGNING_IDENTITY }}
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          artifacts='${{ steps.tauri_build.outputs.artifactPaths }}'
-          dmg_path=$(echo "$artifacts" | jq -r '.[] | select(endswith(".dmg"))')
-          if [ -z "$dmg_path" ]; then
-            echo "::error::No DMG found in tauri build artifacts"
-            exit 1
-          fi
-          echo "DMG: $dmg_path"
-
-          echo "Signing DMG..."
-          codesign --force --sign "$APPLE_SIGNING_IDENTITY" --timestamp "$dmg_path"
-
-          echo "Submitting DMG for notarization..."
-          xcrun notarytool submit "$dmg_path" \
-            --apple-id "$APPLE_ID" \
-            --password "$APPLE_PASSWORD" \
-            --team-id "$APPLE_TEAM_ID" \
-            --wait
-
-          echo "Stapling notarization ticket..."
-          xcrun stapler staple "$dmg_path"
-
-          echo "Verifying..."
-          spctl --assess --type install --verbose "$dmg_path"
-
-          echo "Replacing release asset with notarized DMG..."
-          gh release upload "$RELEASE_TAG" "$dmg_path" --repo "${{ github.repository }}" --clobber
-
-      - name: Build macOS app (smoke only)
-        if: env.IS_SMOKE_TAG == 'true'
-        run: npm run tauri --workspace=@getpaseo/desktop build -- --target ${{ matrix.rust_target }} --no-bundle
+        run: gh release upload "$RELEASE_TAG" latest-mac.yml --clobber --repo "${{ github.repository }}"
 
   publish-linux:
-    if: ${{ (github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'linux')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-linux-v'))) }}
+    needs: [create-release]
+    if: ${{ always() && (needs.create-release.result == 'success' || needs.create-release.result == 'skipped') && ((github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'linux')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-linux-v')))) }}
     permissions:
       contents: write
       packages: read
@@ -248,211 +269,60 @@ jobs:
 
       - name: Resolve release metadata
         shell: bash
-        run: |
-          set -euo pipefail
-          source_tag="${SOURCE_TAG}"
-          if [[ "$source_tag" =~ ^(desktop-(windows|linux|macos)-|desktop-)?v([0-9]+\.[0-9]+\.[0-9]+) ]]; then
-            release_tag="v${BASH_REMATCH[3]}"
-          else
-            release_tag="$source_tag"
-          fi
-          echo "RELEASE_TAG=$release_tag" >> "$GITHUB_ENV"
-
-          version="${release_tag#v}"
-          echo "DESKTOP_VERSION=$version" >> "$GITHUB_ENV"
-
-          if [[ "$source_tag" == *gha-smoke* ]]; then
-            echo "IS_SMOKE_TAG=true" >> "$GITHUB_ENV"
-          else
-            echo "IS_SMOKE_TAG=false" >> "$GITHUB_ENV"
-          fi
-
-      - name: Set desktop version from tag
-        shell: bash
-        run: |
-          node <<'NODE'
-          const fs = require('node:fs');
-          const path = require('node:path');
-          const version = process.env.DESKTOP_VERSION;
-          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
-          console.log(`Setting desktop version to ${version}`);
-
-          const tauriConfPath = path.join('packages', 'desktop', 'src-tauri', 'tauri.conf.json');
-          const tauriConfText = fs.readFileSync(tauriConfPath, 'utf8');
-          const tauriRe = /("version"\s*:\s*")([^"]+)(")/;
-          if (!tauriRe.test(tauriConfText)) throw new Error('Failed to find version in tauri.conf.json');
-          fs.writeFileSync(tauriConfPath, tauriConfText.replace(tauriRe, `$1${version}$3`));
-
-          const cargoTomlPath = path.join('packages', 'desktop', 'src-tauri', 'Cargo.toml');
-          const lines = fs.readFileSync(cargoTomlPath, 'utf8').split(/\r?\n/);
-          let inPackage = false, updated = false;
-          const result = lines.map((line) => {
-            if (/^\[package\]\s*$/.test(line)) inPackage = true;
-            else if (inPackage && /^\[/.test(line)) inPackage = false;
-            if (inPackage && /^version\s*=\s*".*"\s*$/.test(line)) {
-              updated = true;
-              return `version = "${version}"`;
-            }
-            return line;
-          });
-          if (!updated) throw new Error('Failed to update Cargo.toml version');
-          fs.writeFileSync(cargoTomlPath, result.join('\n') + '\n');
-          NODE
-
-      - name: Install Linux packaging dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libgtk-3-dev libappindicator3-dev librsvg2-dev patchelf libfuse2
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
 
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
-          cache: "npm"
+          node-version: '22'
+          cache: 'npm'
           cache-dependency-path: package-lock.json
-          registry-url: "https://npm.pkg.github.com"
-          scope: "@boudra"
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Restore Rust cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: desktop-release-linux
-          workspaces: |
-            .
-            packages/desktop/src-tauri -> target
+          registry-url: 'https://npm.pkg.github.com'
+          scope: '@boudra'
 
       - name: Install JS dependencies
         run: npm ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build web app for Tauri
+      - name: Set desktop package version from tag
+        shell: bash
+        run: |
+          node <<'NODE'
+          const fs = require('node:fs');
+          const path = require('node:path');
+
+          const version = process.env.DESKTOP_VERSION;
+          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
+
+          const packageJsonPath = path.join(process.env.DESKTOP_PACKAGE_PATH, 'package.json');
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+          packageJson.version = version;
+          fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+          NODE
+
+      - name: Build web app for desktop
         run: npm run build:web --workspace=@getpaseo/app
 
-      - name: Build managed runtime
-        run: npm run prepare:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Validate managed runtime bundle
-        run: npm run validate:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Strip CUDA dependencies from onnxruntime
+      - name: Build desktop release
         shell: bash
-        run: |
-          find packages/desktop/src-tauri/resources/managed-runtime -path '*/onnxruntime-node/bin/*' \( -name '*cuda*' -o -name '*tensorrt*' \) -delete || true
-          # Remove CUDA shared library references from onnxruntime .so files so linuxdeploy
-          # doesn't try to bundle them (they're optional runtime deps, not needed for CPU inference)
-          for f in $(find packages/desktop/src-tauri/resources/managed-runtime -path '*/onnxruntime-node/bin/*' \( -name '*.so' -o -name '*.so.*' \)); do
-            for lib in $(patchelf --print-needed "$f" 2>/dev/null | grep -iE 'cublas|cudnn|cudart|cufft|curand|cusolver|cusparse|nccl|nvrtc|tensorrt|nvinfer'); do
-              echo "Removing needed $lib from $f"
-              patchelf --remove-needed "$lib" "$f"
-            done
-          done
-
-      - name: Detect existing GitHub release state
-        if: env.IS_SMOKE_TAG != 'true'
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        shell: bash
+          EP_GH_IGNORE_TIME: true
         run: |
           set -euo pipefail
-          if release_draft="$(gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" --json isDraft --jq '.isDraft' 2>/dev/null)"; then
-            :
-          else
-            release_draft="false"
-          fi
-          echo "RELEASE_DRAFT=$release_draft" >> "$GITHUB_ENV"
-
-      - name: Build Linux Tauri release
-        if: env.IS_SMOKE_TAG != 'true'
-        id: linux_tauri
-        continue-on-error: true
-        env:
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          NO_STRIP: "1"
-          APPIMAGE_EXTRACT_AND_RUN: "1"
-        shell: bash
-        run: |
-          set -euo pipefail
-          npm run tauri --workspace=@getpaseo/desktop build -- --bundles appimage
-
-      - name: Attempt manual Linux AppImage fallback
-        if: env.IS_SMOKE_TAG != 'true' && steps.linux_tauri.outcome == 'failure'
-        env:
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        shell: bash
-        run: |
-          set -euxo pipefail
-          appimage_dir="packages/desktop/src-tauri/target/release/bundle/appimage"
-          appdir_path="$appimage_dir/Paseo.AppDir"
-          canonical_appimage="$appimage_dir/Paseo_${DESKTOP_VERSION}_amd64.AppImage"
-          existing_appimage="$(find "$appimage_dir" -maxdepth 1 -type f -name '*.AppImage' | head -n 1)"
-          if [ -n "$existing_appimage" ]; then
-            if [ "$existing_appimage" != "$canonical_appimage" ]; then
-              mv "$existing_appimage" "$canonical_appimage"
-            fi
-            if [ ! -f "$canonical_appimage.sig" ]; then
-              npx tauri signer sign "$canonical_appimage"
-            fi
-            exit 0
-          fi
-          if [ ! -d "$appdir_path" ]; then
-            echo "::error::AppDir was not generated at $appdir_path"
-            exit 1
-          fi
-          cp --remove-destination "$appdir_path/usr/share/applications/Paseo.desktop" "$appdir_path/Paseo.desktop"
-          cp --remove-destination "$appdir_path/Paseo.png" "$appdir_path/.DirIcon"
-          env | sort | grep -E '^(APPIMAGE|DESKTOP_VERSION|NO_STRIP|RELEASE_TAG|SOURCE_TAG|TAURI_)' || true
-          tools_dir="$(mktemp -d)"
-          curl -fsSL https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage -o "$tools_dir/appimagetool-x86_64.AppImage"
-          chmod +x "$tools_dir/appimagetool-x86_64.AppImage"
-          ARCH=x86_64 APPIMAGE_EXTRACT_AND_RUN=1 "$tools_dir/appimagetool-x86_64.AppImage" "$appdir_path" "$canonical_appimage"
-          npx tauri signer sign "$canonical_appimage"
-
-      - name: Fail Linux release when AppImage bundling fails
-        if: env.IS_SMOKE_TAG != 'true' && steps.linux_tauri.outcome == 'failure'
-        shell: bash
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          assets=(
-            packages/desktop/src-tauri/target/release/bundle/appimage/*.AppImage
-            packages/desktop/src-tauri/target/release/bundle/appimage/*.AppImage.sig
-          )
-          if [ "${#assets[@]}" -eq 0 ]; then
-            echo "::error::Linux AppImage assets are still missing after the manual fallback."
-            exit 1
+          publish_mode="never"
+          publish_args=()
+          if [[ "$IS_SMOKE_TAG" != "true" ]]; then
+            publish_mode="always"
+            publish_args+=("-c.publish.releaseType=$RELEASE_TYPE")
           fi
 
-      - name: Upload Linux release assets
-        if: env.IS_SMOKE_TAG != 'true'
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        shell: bash
-        run: |
-          set -euo pipefail
-          shopt -s nullglob
-          assets=(
-            packages/desktop/src-tauri/target/release/bundle/appimage/*.AppImage
-            packages/desktop/src-tauri/target/release/bundle/appimage/*.AppImage.sig
-          )
-          if [ "${#assets[@]}" -eq 0 ]; then
-            echo "::error::No Linux AppImage assets were produced."
-            exit 1
-          fi
-          printf 'Uploading Linux assets:\n%s\n' "${assets[@]}"
-          gh release upload "$RELEASE_TAG" "${assets[@]}" --repo "${{ github.repository }}" --clobber
-
-      - name: Build Linux app (smoke only)
-        if: env.IS_SMOKE_TAG == 'true'
-        run: npm run tauri --workspace=@getpaseo/desktop build -- --no-bundle
+          npm run build --workspace="$DESKTOP_WORKSPACE" -- --publish "$publish_mode" --linux --x64 "${publish_args[@]}"
 
   publish-windows:
-    if: ${{ (github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'windows')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-windows-v'))) }}
+    needs: [create-release]
+    if: ${{ always() && (needs.create-release.result == 'success' || needs.create-release.result == 'skipped') && ((github.event_name == 'workflow_dispatch' && (github.event.inputs.platform == 'all' || github.event.inputs.platform == 'windows')) || (github.event_name == 'push' && (startsWith(github.ref_name, 'v') || startsWith(github.ref_name, 'desktop-v') || startsWith(github.ref_name, 'desktop-windows-v')))) }}
     permissions:
       contents: write
       packages: read
@@ -466,128 +336,61 @@ jobs:
 
       - name: Resolve release metadata
         shell: bash
-        run: |
-          set -euo pipefail
-          source_tag="${SOURCE_TAG}"
-          if [[ "$source_tag" =~ ^(desktop-(windows|linux|macos)-|desktop-)?v([0-9]+\.[0-9]+\.[0-9]+) ]]; then
-            release_tag="v${BASH_REMATCH[3]}"
-          else
-            release_tag="$source_tag"
-          fi
-          echo "RELEASE_TAG=$release_tag" >> "$GITHUB_ENV"
-
-          version="${release_tag#v}"
-          echo "DESKTOP_VERSION=$version" >> "$GITHUB_ENV"
-
-          if [[ "$source_tag" == *gha-smoke* ]]; then
-            echo "IS_SMOKE_TAG=true" >> "$GITHUB_ENV"
-          else
-            echo "IS_SMOKE_TAG=false" >> "$GITHUB_ENV"
-          fi
-
-      - name: Set desktop version from tag
-        shell: bash
-        run: |
-          node <<'NODE'
-          const fs = require('node:fs');
-          const path = require('node:path');
-          const version = process.env.DESKTOP_VERSION;
-          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
-          console.log(`Setting desktop version to ${version}`);
-
-          const tauriConfPath = path.join('packages', 'desktop', 'src-tauri', 'tauri.conf.json');
-          const tauriConfText = fs.readFileSync(tauriConfPath, 'utf8');
-          const tauriRe = /("version"\s*:\s*")([^"]+)(")/;
-          if (!tauriRe.test(tauriConfText)) throw new Error('Failed to find version in tauri.conf.json');
-          fs.writeFileSync(tauriConfPath, tauriConfText.replace(tauriRe, `$1${version}$3`));
-
-          const cargoTomlPath = path.join('packages', 'desktop', 'src-tauri', 'Cargo.toml');
-          const lines = fs.readFileSync(cargoTomlPath, 'utf8').split(/\r?\n/);
-          let inPackage = false, updated = false;
-          const result = lines.map((line) => {
-            if (/^\[package\]\s*$/.test(line)) inPackage = true;
-            else if (inPackage && /^\[/.test(line)) inPackage = false;
-            if (inPackage && /^version\s*=\s*".*"\s*$/.test(line)) {
-              updated = true;
-              return `version = "${version}"`;
-            }
-            return line;
-          });
-          if (!updated) throw new Error('Failed to update Cargo.toml version');
-          fs.writeFileSync(cargoTomlPath, result.join('\n') + '\n');
-          NODE
+        run: node scripts/emit-release-env.mjs --source-tag "$SOURCE_TAG" >> "$GITHUB_ENV"
 
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: "22"
-          cache: "npm"
+          node-version: '22'
+          cache: 'npm'
           cache-dependency-path: package-lock.json
-          registry-url: "https://npm.pkg.github.com"
-          scope: "@boudra"
-
-      - name: Install Rust stable
-        uses: dtolnay/rust-toolchain@stable
-
-      - name: Restore Rust cache
-        uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: desktop-release-windows
-          workspaces: |
-            .
-            packages/desktop/src-tauri -> target
+          registry-url: 'https://npm.pkg.github.com'
+          scope: '@boudra'
 
       - name: Install JS dependencies
         run: npm ci
         env:
           NODE_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build web app for Tauri
+      - name: Set desktop package version from tag
+        shell: bash
+        run: |
+          node <<'NODE'
+          const fs = require('node:fs');
+          const path = require('node:path');
+
+          const version = process.env.DESKTOP_VERSION;
+          if (!version) throw new Error('DESKTOP_VERSION env var is missing');
+
+          const packageJsonPath = path.join(process.env.DESKTOP_PACKAGE_PATH, 'package.json');
+          const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+          packageJson.version = version;
+          fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+          NODE
+
+      - name: Build workspace dependencies
+        run: npm run build:workspace-deps --workspace=@getpaseo/app
+
+      - name: Build web app for desktop
         shell: pwsh
         run: |
           $patchPath = (Get-Item "$env:GITHUB_WORKSPACE/scripts/metro-config-windows-loader-patch.cjs").FullName
           $env:NODE_OPTIONS = "--require=$patchPath"
-          npm run build:web --workspace=@getpaseo/app
+          npx expo export --platform web
+        working-directory: packages/app
 
-      - name: Build managed runtime
-        run: npm run prepare:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Validate managed runtime bundle
-        run: npm run validate:managed-runtime --workspace=@getpaseo/desktop
-
-      - name: Detect existing GitHub release state
-        if: env.IS_SMOKE_TAG != 'true'
+      - name: Build desktop release
+        shell: bash
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        shell: bash
+          EP_GH_IGNORE_TIME: true
         run: |
           set -euo pipefail
-          if release_draft="$(gh release view "$RELEASE_TAG" --repo "${{ github.repository }}" --json isDraft --jq '.isDraft' 2>/dev/null)"; then
-            :
-          else
-            release_draft="false"
+          publish_mode="never"
+          publish_args=()
+          if [[ "$IS_SMOKE_TAG" != "true" ]]; then
+            publish_mode="always"
+            publish_args+=("-c.publish.releaseType=$RELEASE_TYPE")
           fi
-          echo "RELEASE_DRAFT=$release_draft" >> "$GITHUB_ENV"
 
-      - name: Build and publish Windows Tauri release
-        if: env.IS_SMOKE_TAG != 'true'
-        uses: tauri-apps/tauri-action@v0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-        with:
-          projectPath: packages/desktop
-          tagName: ${{ env.RELEASE_TAG }}
-          releaseName: Paseo ${{ env.RELEASE_TAG }}
-          releaseBody: See the assets to download and install this version.
-          releaseDraft: ${{ env.RELEASE_DRAFT }}
-          prerelease: false
-          args: --bundles nsis
-
-      - name: Build Windows app (smoke only)
-        if: env.IS_SMOKE_TAG == 'true'
-        run: npm run tauri --workspace=@getpaseo/desktop build -- --no-bundle
-        env:
-          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
-          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+          npm run build --workspace="$DESKTOP_WORKSPACE" -- --publish "$publish_mode" --win --x64 "${publish_args[@]}"

.github/workflows/fix-nix-hash.yml

@@ -0,0 +1,45 @@
+name: Fix Nix hash
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+  pull_request:
+    paths:
+      - 'package.json'
+      - 'package-lock.json'
+
+permissions:
+  contents: write
+
+jobs:
+  fix-nix-hash:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref || github.ref }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - uses: cachix/install-nix-action@v31
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+
+      - name: Fix lockfile and update hash
+        run: ./scripts/update-nix.sh
+
+      - name: Commit changes
+        run: |
+          git diff --quiet package-lock.json nix/package.nix && exit 0
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add package-lock.json nix/package.nix
+          git commit -m "fix: update lockfile signatures and Nix hash"
+          git push

.github/workflows/nix-build.yml

@@ -0,0 +1,59 @@
+name: Nix Build
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'nix/**'
+      - 'flake.nix'
+      - 'flake.lock'
+      - 'package.json'
+      - 'package-lock.json'
+      - 'packages/highlight/**'
+      - 'packages/server/**'
+      - 'packages/relay/**'
+      - 'packages/cli/**'
+  pull_request:
+    branches: [main]
+    paths:
+      - 'nix/**'
+      - 'flake.nix'
+      - 'flake.lock'
+      - 'package.json'
+      - 'package-lock.json'
+      - 'packages/highlight/**'
+      - 'packages/server/**'
+      - 'packages/relay/**'
+      - 'packages/cli/**'
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    continue-on-error: false
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: cachix/install-nix-action@v31
+        with:
+          nix_path: nixpkgs=channel:nixos-unstable
+
+      - name: Build Nix package
+        run: nix build .#default -o result
+
+      - name: Verify lockfile is complete
+        # npm silently omits resolved/integrity fields in workspace monorepos.
+        # Nix needs them for offline builds. See https://github.com/npm/cli/issues/4460
+        run: |
+          node scripts/fix-lockfile.mjs package-lock.json
+          git diff --exit-code package-lock.json || {
+            echo "ERROR: package-lock.json has missing resolved/integrity fields."
+            echo "This is a known npm bug: https://github.com/npm/cli/issues/4460"
+            echo "Run 'node scripts/fix-lockfile.mjs' and commit the result."
+            exit 1
+          }
+
+      - name: Check npmDepsHash is up to date
+        run: ./scripts/update-nix.sh --check

.github/workflows/release-notes-sync.yml

@@ -19,11 +19,6 @@ on:
         required: false
         default: false
         type: boolean
-      draft:
-        description: "Create missing release as draft."
-        required: false
-        default: false
-        type: boolean
 
 concurrency:
   group: release-notes-sync-${{ github.event_name == 'workflow_dispatch' && github.event.inputs.tag || github.ref }}
@@ -48,7 +43,6 @@ jobs:
           REF: ${{ github.ref }}
           INPUT_TAG: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/') && github.ref_name || github.event.inputs.tag }}
           INPUT_CREATE_IF_MISSING: ${{ github.event.inputs.create_if_missing }}
-          INPUT_DRAFT: ${{ github.event.inputs.draft }}
         shell: bash
         run: |
           set -euo pipefail
@@ -70,8 +64,4 @@ jobs:
             args+=(--create-if-missing)
           fi
 
-          if [ "${INPUT_DRAFT:-false}" = "true" ]; then
-            args+=(--draft)
-          fi
-
           node scripts/sync-release-notes-from-changelog.mjs "${args[@]}"

.github/workflows/server-ci.yml

@@ -36,6 +36,9 @@ jobs:
       - name: Install server dependencies
         run: npm install --workspace=@getpaseo/server --include-workspace-root
 
+      - name: Build highlight dependency
+        run: npm run build --workspace=@getpaseo/highlight
+
       - name: Build relay dependency
         run: npm run build --workspace=@getpaseo/relay
 
@@ -44,3 +47,6 @@ jobs:
 
       - name: Test
         run: npm run test --workspace=@getpaseo/server
+        env:
+          CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}

.gitignore

@@ -46,6 +46,9 @@ test-results/
 # Vercel
 .vercel/
 
+# Expo
+.expo/
+
 # Misc
 *.pem
 .vercel

.prettierignore

@@ -1,21 +0,0 @@
-# Dependencies
-node_modules
-
-# Build outputs
-dist
-.next
-.expo
-build
-*.tsbuildinfo
-
-# Coverage
-coverage
-
-# Lock files
-*.lock
-package-lock.json
-
-# Generated
-android
-ios
-.turbo

.prettierrc

@@ -1,7 +0,0 @@
-{
-  "semi": false,
-  "singleQuote": true,
-  "trailingComma": "es5",
-  "tabWidth": 2,
-  "printWidth": 100
-}

CHANGELOG.md

@@ -1,5 +1,374 @@
 # Changelog
 
+## 0.1.53 - 2026-04-12
+
+### Added
+- Agents get Paseo tools automatically — every new agent gets access to terminals, schedules, worktrees, and other agents through MCP. Toggle it off in Settings under "Inject Paseo tools".
+- Git pull — pull remote changes directly from the workspace header. Promoted to the primary action when your branch is behind origin.
+- Child agent notifications — parent agents are automatically notified when a child agent finishes, errors, or needs permission approval.
+- Agent reload — `paseo agent reload` restarts an agent's underlying process from the CLI.
+- Middle-click to close tabs on desktop.
+- Keyboard shortcut to cycle themes.
+
+### Improved
+- Unavailable git actions now explain why in a toast instead of being silently greyed out.
+- Streaming markdown on mobile renders significantly faster.
+- Sidebar, branch switcher, and agent panel no longer re-render unnecessarily — noticeable on large workspaces.
+- Paseo tool calls in agent timelines show the Paseo logo and human-readable names.
+- Relay and pairing URLs are stripped from daemon logs.
+
+### Fixed
+- Closed agent tabs no longer reappear after reconnecting.
+- Desktop notification badge counts match across all workspaces.
+- Host switcher status syncs correctly when switching between hosts.
+
+## 0.1.52 - 2026-04-10
+
+### Added
+- Theme selector — choose from six themes including Midnight, Claude, and Ghostty dark variants.
+- Branch switching — switch git branches directly from the workspace header, with automatic stash and restore for uncommitted changes.
+- Auto-download updates — desktop updates download silently in the background so they're ready to install when you are.
+
+### Fixed
+- Layout now responds correctly when resizing the window or rotating a tablet — previously the app could get stuck in mobile layout on a large screen.
+- Terminal no longer causes massive memory spikes from snapshot thrashing during heavy output.
+- Typing in the terminal works reliably — special keys, Ctrl combos, and paste are handled natively by the terminal emulator.
+- Initializing agents no longer show a loading spinner as if they're running.
+- Reconnecting to a running agent now works even when session persistence is unavailable.
+- Error screens on desktop are now scrollable.
+- Model list refreshes in the background when you open the model selector.
+- Draft agent feature preferences (like thinking mode) are remembered across sessions.
+
+## 0.1.51 - 2026-04-09
+
+### Added
+- Image attachments for OpenCode — attach screenshots and images to OpenCode agent prompts.
+- WebStorm — added to the "Open in editor" list alongside Cursor, VS Code, and Zed.
+- Send behavior setting — choose whether pressing Enter while an agent is running interrupts immediately or queues your message.
+
+### Fixed
+- Model selector no longer crashes on iPad.
+- Pairing now uses the correct hostname, fixing connection failures on some network setups.
+- OpenCode agents show the correct terminal state and refresh models reliably.
+- Follow-up messages to agents that just finished a turn now work correctly.
+- Commands now load properly for Pi agents.
+- Internal debug output no longer appears in Claude agent timelines.
+- QR scan screen cleaned up with simpler visuals.
+
+## 0.1.50 - 2026-04-07
+
+### Added
+- Context window meter — see how much of the context window your agent has used, with color thresholds at 70% and 90%. Works with Claude Code, Codex, and OpenCode.
+- Open in editor — jump from any workspace straight into Cursor, VS Code, Zed, or your file manager. Paseo remembers your choice.
+- Side-by-side diffs — toggle between unified and split-column diff views, with a whitespace visibility option.
+- Spoken messages — when using voice mode, agent speech now appears as regular messages in the conversation instead of raw tool output.
+- Plan actions — plan cards now show the actions your agent supports (e.g. "Implement", "Deny") instead of generic accept/reject buttons.
+- Background git fetch — ahead/behind counts in the Changes pane stay up to date automatically.
+
+### Improved
+- Workspaces load instantly on connect instead of waiting for a full sync.
+- File explorer and diff pane remember which folders are expanded when you switch tabs.
+- Closing a workspace tab is now instant.
+- Settings shows a Refresh button for providers and displays error details inline.
+- Reload agent moved away from the close button to prevent accidental taps.
+
+### Fixed
+- Voice mode no longer drifts into false speech detection during long sessions.
+- Garbled overlapping text on plan cards.
+- Changes pane could show stale diffs when working with git worktrees.
+- Restarting an agent quickly could crash the session.
+- Copilot no longer pauses for permission prompts in autopilot mode.
+- Connection and pairing dialogs now display correctly on tablets.
+- Orchestration errors from agents are now surfaced instead of silently lost.
+- Diff stats no longer reset to zero when reconnecting.
+
+## 0.1.49 - 2026-04-07
+
+### Fixed
+- Models and providers now load reliably on first connect instead of requiring a manual refresh.
+- Model picker only shows models from the agent's own provider, not every provider on the server.
+- Model lists stay consistent regardless of which screen you open first.
+
+## 0.1.48 - 2026-04-05
+
+### Added
+- Provider diagnostics — tap a provider in Settings to see binary path, version, model count, and status at a glance. Helps troubleshoot why an agent type isn't available.
+- Provider snapshot system — daemon now pushes real-time provider availability and model lists to the app, replacing the old poll-based approach. Models and modes update live as providers come online or go offline.
+- Codex question handling — Codex agents can now ask the user questions mid-session (e.g. "which file?") and receive answers inline, matching the Claude Code question flow.
+- Reload tab action — right-click a workspace tab to reload its agent list without restarting the app.
+
+### Improved
+- Model selector redesigned — grouped by provider with status badges, search, and better touch targets on mobile.
+- Enter key now submits question card answers and confirms dictation, matching the expected keyboard flow.
+- Removed noisy agent lifecycle toasts that fired on every state change.
+
+### Fixed
+- Desktop app now resolves the user's full login shell environment at startup, fixing tools like `codex`, `node`, `bun`, and `direnv` not being found when Paseo is launched from Finder or Dock. Terminals spawned by Paseo now inherit the same PATH and environment variables as a normal terminal session. Approach adapted from VS Code's battle-tested shell environment resolution.
+- Input field on running agent screens now correctly receives keyboard focus.
+- Mobile model selector alignment and sizing.
+
+## 0.1.47 - 2026-04-05
+
+### Fixed
+- Voice TTS in Electron — sherpa now requests copied buffers and the voice MCP bridge sets `ELECTRON_RUN_AS_NODE`, preventing "external buffers not allowed" crashes.
+- QR pairing in desktop — CLI JSON output parsing now tolerates Node deprecation warnings in stdout.
+- STT segment race condition — segment ID and audio buffer are snapshotted before the async transcription call, so rapid commits no longer interleave.
+- Per-host "Add connection" button removed — it blocked multi-host setups by scoping new connections to a single server.
+
+## 0.1.46 - 2026-04-04
+
+### Fixed
+- Voice activation in packaged builds — Silero VAD model is now copied out of the Electron asar archive so native code can read it.
+- App version sent in probe client hello so the daemon's version gate no longer hides Pi/Copilot from reconnected sessions.
+- `worktreeRoot` schema made backward-compatible for old clients and daemons that don't send the field.
+- Punycode deprecation warning (DEP0040) suppressed in CLI and desktop daemon entrypoints.
+
+## 0.1.45 - 2026-04-04
+
+### Added
+- Pi (pi.dev) agent provider — connect Pi as a new ACP-based agent type with thinking levels and tool call support.
+- Copilot agent provider re-enabled after ACP compatibility fixes.
+- `paseo .` and `paseo <path>` open the desktop app with the given project, similar to `code .`.
+- Provider-declared features system — providers can expose dynamic toggles and selects that the app renders automatically. First consumer: Codex fast mode.
+- Codex plan mode — start agents in plan-only mode with a dedicated plan card UI for reviewing proposed changes before execution.
+- OpenCode custom agents and slash commands — user-defined agents from opencode.json now appear in the mode picker, and slash commands accept optional arguments.
+- Desktop Integrations settings — install the Paseo CLI and orchestration skills directly from the app without touching the terminal.
+- Daemon status dialog in desktop settings for quick health checks.
+- Auto-restart daemon on version mismatch — the desktop app detects when the running daemon is outdated and restarts it automatically.
+- Setup hint and paseo.sh link on the mobile welcome screen so new App Store users know what to do next.
+
+### Improved
+- Desktop startup is faster — existing daemon connections are raced against bootstrap so the app is usable sooner.
+- Settings sections reordered for better grouping (integrations and daemon together).
+- Sidebar projects and workspaces now persist across sessions, with a context menu to remove projects.
+
+### Fixed
+- Sidebar crash when switching iOS theme (Unistyles/Reanimated interaction).
+- Silero VAD crash caused by external buffer mode in CircularBuffer.
+- Bulk close now correctly archives stored agents instead of leaving orphans.
+- Pinned archived agents are no longer pruned when closing tabs.
+- OpenCode event stream starvation during slash command execution.
+- Duplicate workspaces when multiple git worktrees share the same root.
+- `gh` executable resolution for desktop users whose login shell sets a different PATH.
+- Agent creation timeout increased to 60s to handle slow first-launch scenarios.
+- Forward-compatible provider handling so older app clients don't break on new provider types.
+- Input event listener race condition in the web scrollbar hook.
+- Open-project screen content now vertically centered.
+- Website download page fetches the release version at runtime with asset validation, fixing stale links.
+
+## 0.1.44 - 2026-04-03
+
+### Fixed
+- Desktop app now stops the daemon cleanly before auto-update restarts.
+- Disabled claude-acp and copilot providers from the agent registry.
+- Keyboard focus scope resolution now checks multiple candidates for broader compatibility.
+- OpenCode interrupt now reaches correct terminal state parity with tool-call flows.
+- Shell injection, symlink escape, and pairing endpoint security hardening.
+
+## 0.1.43 - 2026-04-02
+
+### Added
+- Copilot agent support via ACP base provider — connect GitHub Copilot as a new agent type.
+- Searchable model favorites — quickly find and pin preferred models.
+- Slash command support for OpenCode agents.
+
+### Improved
+- Refined model selector UX with better mobile sheet behavior.
+- Workspace status now uses amber alert styling for "needs input" state.
+- Themed scrollbar on message input for consistent styling.
+
+### Fixed
+- Ctrl+C/V copy and paste now works correctly in the terminal on Windows and Linux.
+- Shell arguments with spaces are now properly quoted on Windows.
+- Claude models with 1M context support are now correctly reported.
+
+## 0.1.42 - 2026-04-01
+
+### Fixed
+- Fixed Claude Code failing to launch on Windows when installed to a path with spaces (e.g. `C:\Program Files\...`).
+
+## 0.1.41 - 2026-04-01
+
+### Fixed
+- Fixed agent spawning on Windows — all providers (Claude, Codex, OpenCode) now use shell mode so npm shims and `.cmd` wrappers resolve correctly.
+- Fixed terminal creation on Windows defaulting to a Unix shell instead of `cmd.exe`.
+- Fixed path handling across the app to support Windows drive-letter paths (`C:\...`) and UNC paths (`\\...`).
+- Fixed executable resolution on Windows to work with `nvm4w` and similar Node version managers.
+- Eliminated white flash on window resize in dark mode by setting the native window background color to match the theme.
+- Fixed titlebar drag region — replaced the fragile pointer-event approach with VS Code's proven static CSS `app-region: drag` pattern.
+- Fixed context menu for copy/paste across the desktop app.
+- Fixed shortcut rebinding UI to show held modifier keys and recognize additional keys (Tab, Delete, Home, End, Page Up/Down, Insert, F1–F12).
+- Removed the 40-item cap on activity timeline output so long agent sessions display their full history.
+
+### Improved
+- Improved light mode theming with dedicated workspace background, scrollbar handle colors, and lighter shadows.
+- Window controls overlay on Windows/Linux reduced from 48px to 29px height for a more compact titlebar.
+
+## 0.1.40 - 2026-04-01
+
+### Added
+- Workspace tabs can now be closed in batches.
+
+### Improved
+- Provider model lists are now cached per server and provider, reducing redundant model lookups in the UI.
+
+### Fixed
+- OpenCode reasoning content no longer appears duplicated as assistant text.
+- Daemon no longer crashes when a Codex binary is missing or fails to spawn.
+- Archive tab now correctly reconciles agent visibility after archiving.
+- File diff tracking in workspaces now works correctly on Linux.
+- iPad layout now renders correctly in desktop mode.
+- macOS auto-updater now correctly delivers both arm64 and x64 binaries — previously whichever architecture finished building last would overwrite the other's update manifest.
+
+## 0.1.39 - 2026-03-30
+
+### Added
+- **Terminal management from the CLI** — new `paseo terminal` command group lets you list, create, and interact with workspace terminals without leaving your terminal.
+- **Material file icons in the explorer** — the file explorer tree now shows language-specific icons (TypeScript, JSON, Markdown, etc.) so you can spot files at a glance.
+
+### Fixed
+- Fixed iOS sidebar scroll flicker caused by redundant overflow clipping.
+- Centralized window controls padding into a shared hook, eliminating layout inconsistencies across platforms.
+
+## 0.1.38 - 2026-03-30
+
+### Fixed
+- Fixed daemon startup race where the app could time out connecting on first launch because the PID file advertised a listen address before the server was ready.
+- Fixed daemon log rotation losing startup traces — trace-level WebSocket logs no longer include full message payloads.
+
+## 0.1.37 - 2026-03-29
+
+### Added
+- Custom window controls on Windows and Linux — the native titlebar is replaced with overlay controls that match the app's design.
+- Desktop file logging with electron-log for easier debugging of daemon and app issues.
+
+### Fixed
+- Fixed broken PATH propagation and Claude binary resolution on Windows.
+- Dictation errors now show a visible toast instead of failing silently.
+
+## 0.1.36 - 2026-03-27
+
+### Fixed
+- Fixed Windows drive-letter path handling across the codebase.
+- Fixed stale Nix hash with automatic lockfile-change detection.
+
+### Added
+- Added metrics collection and terminal performance tests.
+
+## 0.1.35 - 2026-03-26
+
+### Improved
+- Faster app startup by redirecting to the welcome screen immediately and showing host connection status inline.
+- Codex file deletions now display correctly as removed lines in diffs.
+- OpenCode questions are now surfaced in the permission UI.
+
+### Fixed
+- Fixed queued prompt dispatch after idle transition.
+- Replaced bash-only `mapfile` with a portable `while-read` loop in the chat script.
+
+### Added
+- Added support for Nix and NixOS installation.
+
+## 0.1.34 - 2026-03-25
+
+### Added
+- Added `paseo archive` as a top-level alias for `paseo agent archive`.
+- Added the `PASEO_AGENT_ID` environment variable for Claude and Codex agents.
+- Added a redesigned command autocomplete with a detail card and dropdown styling.
+- Linked Android download surfaces to the Google Play Store.
+
+### Improved
+- Autonomous turns now complete gracefully on interrupt instead of being canceled.
+- Thinking/model selection now always resolves to a real option instead of showing a generic Default choice.
+- Restored per-provider form preferences and removed the Auto model fallback.
+- Improved Codex activity logs with clearer tool-call summaries.
+- Reduced unnecessary re-renders in the agent panel and input area for smoother interaction.
+- Improved chat transcript readability.
+
+### Fixed
+- Fixed `paseo send --no-wait` not taking effect.
+- Fixed stale abort results contaminating replacement turns after an interrupt.
+- Fixed Claude interrupt handling and autonomous wake reliability.
+- Fixed nested Claude Code session detection and provider availability checks.
+- Fixed agent input focus scoping across panels.
+- Fixed terminal snapshot ordering when subscribing.
+- Fixed `chat read --since` to accept message IDs.
+- Fixed keyboard pane focus syncing with the active panel.
+- Fixed assistant text selection on web.
+- Fixed archived-agent notifications still appearing in chat rooms.
+- Fixed the attach-images button interaction in the message composer.
+- Pruned wrong-platform native binaries from Electron desktop builds.
+
+## 0.1.33 - 2026-03-23
+
+### Fixed
+- Fixed the desktop app failing to reopen after closing on macOS — the daemon and agent processes were registering with Launch Services as instances of the main app, blocking subsequent launches.
+- Fixed dictation not working in the packaged desktop app — the microphone entitlement was missing from the hardened runtime configuration.
+- Fixed leaked Claude Code child processes when agents were closed — the SDK query stream was not being properly shut down.
+- The notification test button now surfaces errors instead of failing silently.
+
+## 0.1.32 - 2026-03-23
+
+### Added
+- Fully rebindable keyboard shortcuts with chord support — all shortcuts are now declarative with proper Cmd (Mac) vs Ctrl (Windows/Linux) separation.
+- Migrated the desktop app from Tauri to Electron, with macOS notarization, code signing, and Linux Wayland support.
+- Added line numbers and word-wrap toggle to file previews.
+- Added an archived agent callout with an unarchive button so you can restore agents directly from the chat view.
+- Added workspace kind indicators in the sidebar (e.g. worktree vs standalone).
+- Expanded diff syntax highlighting to cover more languages.
+- Added status bar tooltips for project and agent status.
+
+### Improved
+- Redesigned the mobile tab switcher as a compact header row with quick access to new agents and terminals.
+- Streamlined workspace creation — worktrees are now created inline with a single action instead of a multi-step flow.
+- Agent history now streams from disk on reconnect, so you see past messages immediately instead of a blank screen.
+- Automatic cleanup of stale workspaces: deleted worktree directories and fully-archived workspaces are pruned automatically.
+- After archiving a workspace, the app now redirects to the next available workspace instead of leaving you on a dead screen.
+- Reopening an archived agent tab now keeps it open instead of collapsing back to archived state.
+- Reduced unnecessary re-renders across the workspace screen, sidebar, and agent list for smoother scrolling and interaction.
+- Agent list no longer refreshes in the background when the screen is unfocused, saving resources.
+- Desktop key repeat now works correctly on macOS.
+- Desktop notifications on macOS are more reliable.
+- Daemon startup no longer blocks on model downloads.
+- Better error messages from the daemon — RPC errors now include the actual underlying details.
+
+### Fixed
+- Fixed user messages appearing as assistant output in the timeline when messages contained structured content blocks.
+- Fixed archived workspace routing so navigating to an archived session no longer breaks the app.
+- Fixed Linux AppImage failing to launch on Wayland-only desktops.
+- Fixed desktop window drag coordinates being applied when they shouldn't be.
+
+## 0.1.30 - 2026-03-19
+
+### Added
+- Added terminal tabs, split pane controls, and drop previews for workspace layouts.
+- Added a combined model selector and agent mode visuals across key UI surfaces.
+- Added Open Graph metadata improvements for richer website sharing previews.
+
+### Improved
+- Improved workspace navigation with better active-workspace tracking and keyboard-driven pane interactions.
+- Improved terminal scrollbar behavior, pane focus handling, and status bar/message input spacing.
+- Improved project picker path display and general workspace UI polish.
+
+### Fixed
+- Fixed agent startup reliability by tightening PATH resolution and surfacing missing provider binaries in status.
+- Fixed workspace route syncing, drag hit areas, and git diff panel header styling regressions.
+- Fixed website mobile horizontal scrolling and ensured the workspace audio module builds during EAS installs.
+
+## 0.1.28 - 2026-03-15
+
+### Added
+- Added OpenCode build and plan modes.
+- Added website landing pages for Claude Code, Codex, and OpenCode.
+
+### Improved
+- Improved the git action menu for more reliable repository actions.
+- Improved the mobile settings screen, workspace header actions, and welcome screen presentation.
+- Updated the website hero copy and added a sponsor callout section.
+
+### Fixed
+- Fixed assistant file links so they open the correct workspace files from chat.
+
 ## 0.1.27 - 2026-03-13
 
 ### Added
@@ -135,7 +504,7 @@
 - Redesigned the website get-started experience into a clearer two-step flow.
 - Simplified website GitHub navigation and changelog headings.
 - Improved app draft/new-agent UX with clearer working directory placeholder and empty-state messaging.
-- Enabled drag interactions in previously unhandled areas on the desktop (Tauri) draft screen.
+- Enabled drag interactions in previously unhandled areas on the desktop draft screen.
 - Hid empty filter groups in the left sidebar.
 
 ### Fixed
@@ -157,7 +526,7 @@
 - Improved new worktree-agent defaults by prefilling CWD to the main repository.
 - Improved desktop command autocomplete behavior to match combobox interactions.
 - Improved git sync UX by simplifying sync labels and only showing Sync when a branch diverges from origin.
-- Improved desktop settings and permissions UX in Tauri.
+- Improved desktop settings and permissions UX on desktop.
 - Improved scrollbar visibility, drag interactions, tracking, and animation timing on web/desktop.
 
 ### Fixed
@@ -196,7 +565,7 @@
 - Fixed stuck "send while running" recovery across app and server session handling.
 - Fixed Claude session identity preservation when reloading existing agents.
 - Fixed combobox option behavior and related interactions.
-- Fixed Tauri file-drop listener cleanup to avoid uncaught unlisten errors.
+- Fixed desktop file-drop listener cleanup to avoid uncaught unlisten errors.
 - Fixed web tool-detail wheel event routing at scroll edges.
 
 ## 0.1.7 - 2026-02-16

CI_STATUS.md

@@ -0,0 +1,19 @@
+# CI Test Status
+
+Tracking progress toward all-green CI.
+
+## CI Jobs
+
+| Job | Status | Notes |
+|-----|--------|-------|
+| format | unknown | `npx biome format .` |
+| typecheck | unknown | `npm run typecheck` |
+| server-tests | unknown | unit + integration (vitest) |
+| app-tests | unknown | unit tests (vitest) |
+| playwright | unknown | E2E tests (playwright) |
+| relay-tests | unknown | unit tests (vitest) |
+| cli-tests | unknown | local tests |
+
+## Log
+
+- 2026-04-10: Branch created, automated agents begin iterating

CLAUDE.md

@@ -12,7 +12,7 @@ This is an npm workspace monorepo:
 - `packages/app` — Mobile + web client (Expo)
 - `packages/cli` — Docker-style CLI (`paseo run/ls/logs/wait`)
 - `packages/relay` — E2E encrypted relay for remote access
-- `packages/desktop` — Tauri desktop wrapper
+- `packages/desktop` — Electron desktop wrapper
 - `packages/website` — Marketing site (paseo.sh)
 
 ## Documentation
@@ -35,6 +35,8 @@ npm run dev                          # Start daemon + Expo in Tmux
 npm run cli -- ls -a -g              # List all agents
 npm run cli -- daemon status         # Check daemon status
 npm run typecheck                    # Always run after changes
+npm run format                       # Auto-format with Biome
+npm run format:check                 # Check formatting without writing
 ```
 
 See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for full setup, build sync requirements, and debugging.
@@ -45,10 +47,15 @@ See [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for full setup, build sync requir
 - **NEVER assume a timeout means the service needs restarting** — timeouts can be transient.
 - **NEVER add auth checks to tests** — agent providers handle their own auth.
 - **Always run typecheck after every change.**
+- **Run `npm run format` before committing.** This repo uses Biome for formatting. Do not manually fix formatting — let the formatter handle it.
+- **NEVER make breaking changes to WebSocket or message schemas.** The primary compatibility path is old mobile app clients talking to newly updated daemons. Users update desktop and daemon first, then keep running the old app for a while. Every schema change MUST be backward-compatible for old clients against new daemons:
+  - New fields: always `.optional()` with a sensible default or `.transform()` fallback.
+  - Never change a field from optional to required.
+  - Never remove a field — deprecate it (keep accepting it, stop sending it).
+  - Never narrow a field's type (e.g. `string` → `enum`, `nullable` → non-null).
+  - Test with: "does a 6-month-old client still parse this?" and "does a 6-month-old daemon still send something this client accepts?"
 
-## Orchestrator mode
+## Debugging
 
-- Prefix agent titles with "🎭" (e.g., "🎭 Feature Implementation")
-- Launch agents in the most permissive mode
-- Set cwd to the repository root
-- When agent control tool calls fail, list agents first — it may be a wait timeout
+
+Find the complete daemon logs and traces in the $PASEO_HOME/daemon.log

CONTRIBUTING.md

@@ -0,0 +1,168 @@
+# Contributing to Paseo
+
+Thanks for taking the time to contribute.
+
+## How this project works
+
+Paseo is a BDFL project. Product direction, scope, and what ships are the maintainer's call.
+
+This means:
+
+- PRs submitted without prior discussion will likely be rejected, heavily modified, or scoped down.
+- The maintainer may rewrite, split, cherry-pick from, or close any PR at their discretion.
+- There is no obligation to merge a PR as-submitted, regardless of code quality.
+
+This is not meant to discourage contributions. It is meant to set clear expectations so nobody wastes their time.
+
+## How to contribute
+
+1. **Open an issue first.** Describe the problem or improvement. Get a thumbs up before writing code.
+2. **Keep it small.** One bug, one flow, one focused change.
+3. **Open a PR** once there is alignment on scope.
+
+If you want to propose a direction change, start a conversation.
+
+## Before you start
+
+Please read these first:
+
+- [README.md](README.md)
+- [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)
+- [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md)
+- [docs/CODING_STANDARDS.md](docs/CODING_STANDARDS.md)
+- [docs/TESTING.md](docs/TESTING.md)
+- [CLAUDE.md](CLAUDE.md)
+
+## What is most helpful
+
+The most useful contributions right now are:
+
+- bug fixes
+- windows and linux specific fixes
+- regression fixes
+- doc improvements
+- packaging / platform fixes
+- focused UX improvements that fit the existing product direction
+- tests that lock down important behavior
+
+## Scope expectations
+
+Please keep PRs narrow.
+
+Good:
+
+- fix one bug
+- improve one flow
+- add one focused panel or command
+- tighten one piece of UI
+
+Bad:
+
+- combine multiple product ideas in one PR
+- bundle unrelated refactors with a feature
+- sneak in roadmap decisions
+
+If a contribution contains multiple ideas, split it up.
+
+## Product fit matters
+
+Paseo is an opinionated product.
+
+When reviewing contributions, the bar is not just:
+
+- is this useful?
+- is this well implemented?
+
+It is also:
+
+- does this fit Paseo?
+- does this add product surface that will be hard to maintain?
+- does the value justify the maintenance surface it adds?
+- does this solve a common need or over-serve an edge case?
+- does this preserve the product's current direction?
+
+## Development setup
+
+### Prerequisites
+
+- Node.js matching `.tool-versions`
+- npm workspaces
+
+### Start local development
+
+```bash
+# runs both daemon and expo app
+npm run dev
+```
+
+Useful commands:
+
+```bash
+npm run dev:server
+npm run dev:app
+npm run dev:desktop
+npm run dev:website
+npm run cli -- ls -a -g
+```
+
+Read [docs/DEVELOPMENT.md](docs/DEVELOPMENT.md) for build-sync gotchas, local state, ports, and daemon details.
+
+## Multi-platform testing
+
+Paseo ships to mobile (iOS/Android), web, and desktop (Electron). Every UI change must be tested on mobile and web at minimum, and desktop if relevant. Things that look fine on one surface regularly break on another.
+
+Common checks:
+
+```bash
+npm run typecheck
+npm run test --workspaces --if-present
+```
+
+Important rules:
+
+- always run `npm run typecheck` after changes
+- tests should be deterministic
+- prefer real dependencies over mocks when possible
+- do not make breaking WebSocket / protocol changes
+- app and daemon versions in the wild lag each other, so compatibility matters
+
+If you touch protocol or shared client/server behavior, read the compatibility notes in [CLAUDE.md](CLAUDE.md).
+
+## Coding standards
+
+Paseo has explicit standards. Follow them.
+
+The full guide lives in [docs/CODING_STANDARDS.md](docs/CODING_STANDARDS.md).
+
+## PR checklist
+
+Before opening a PR, make sure:
+
+- there was prior discussion and alignment on scope (issue or conversation)
+- the change is focused, one idea per PR
+- the PR description explains what changed and why
+- **UI changes include screenshots or videos** for every affected platform (mobile, web, desktop)
+- UI changes have been tested on mobile and web at minimum
+- typecheck passes
+- tests pass, or you clearly explain what could not be run
+- relevant docs were updated if needed
+
+## Communication
+
+If you are unsure whether something fits, ask first.
+
+That is especially true for:
+
+- new core UX
+- naming / terminology changes
+- new extension points
+- new orchestration models
+- anything that would be hard to remove later
+
+Early alignment saves everyone time.
+
+## Forks are fine
+
+If you want to explore a different product direction, a fork is completely fine.
+
+Paseo is open source on purpose. Not every idea needs to land in the main repo to be valuable.

README.md

@@ -4,39 +4,122 @@
 
 <h1 align="center">Paseo</h1>
 
-<p align="center">Manage coding agents from your phone and desktop.</p>
+<p align="center">
+  <a href="https://github.com/getpaseo/paseo/stargazers">
+    <img src="https://img.shields.io/github/stars/getpaseo/paseo?style=flat&logo=github" alt="GitHub stars">
+  </a>
+  <a href="https://github.com/getpaseo/paseo/releases">
+    <img src="https://img.shields.io/github/v/release/getpaseo/paseo?style=flat&logo=github" alt="GitHub release">
+  </a>
+  <a href="https://x.com/moboudra">
+    <img src="https://img.shields.io/badge/%40moboudra-555?logo=x" alt="X">
+  </a>
+  <a href="https://discord.gg/jz8T2uahpH">
+    <img src="https://img.shields.io/badge/Discord-555?logo=discord" alt="Discord">
+  </a>
+</p>
+
+<p align="center">One interface for all your Claude Code, Codex and OpenCode agents.</p>
 
 <p align="center">
-  <img src="https://paseo.sh/paseo-mockup.png" alt="Paseo app screenshot" width="100%">
+  <img src="https://paseo.sh/hero-mockup.png" alt="Paseo app screenshot" width="100%">
+</p>
+
+<p align="center">
+  <img src="https://paseo.sh/mobile-mockup.png" alt="Paseo mobile app" width="100%">
 </p>
 
 ---
 
-> [!WARNING]
-> **Early development** — Features may break or change without notice. Use at your own risk.
+Run agents in parallel on your own machines. Ship from your phone or your desk.
 
-Paseo is a self-hosted daemon for Claude Code, Codex, and OpenCode. Agents run on your machine with your full dev environment. Connect from phone, desktop, or web.
+- **Self-hosted:** Agents run on your machine with your full dev environment. Use your tools, your configs, and your skills.
+- **Multi-provider:** Claude Code, Codex, and OpenCode through the same interface. Pick the right model for each job.
+- **Voice control:** Dictate tasks or talk through problems in voice mode. Hands-free when you need it.
+- **Cross-device:** iOS, Android, desktop, web, and CLI. Start work at your desk, check in from your phone, script it from the terminal.
+- **Privacy-first:** Paseo doesn't have any telemetry, tracking, or forced log-ins.
 
 ## Getting Started
 
+Paseo runs a local server called the daemon that manages your coding agents. Clients like the desktop app, mobile app, web app, and CLI connect to it.
+
+### Prerequisites
+
+You need at least one agent CLI installed and configured with your credentials:
+
+- [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
+- [Codex](https://github.com/openai/codex)
+- [OpenCode](https://github.com/anomalyco/opencode)
+
+### Desktop app (recommended)
+
+Download it from [paseo.sh/download](https://paseo.sh/download) or the [GitHub releases page](https://github.com/getpaseo/paseo/releases). Open the app and the daemon starts automatically. Nothing else to install.
+
+To connect from your phone, scan the QR code shown in Settings.
+
+### CLI / headless
+
+Install the CLI and start Paseo:
+
 ```bash
 npm install -g @getpaseo/cli
 paseo
 ```
 
-Then open the app and connect to your daemon.
+This shows a QR code in the terminal. Connect from any client. This path is useful for servers and remote machines.
 
 For full setup and configuration, see:
 - [Docs](https://paseo.sh/docs)
 - [Configuration reference](https://paseo.sh/docs/configuration)
 
+## CLI
+
+Everything you can do in the app, you can do from the terminal.
+
+```bash
+paseo run --provider claude/opus-4.6 "implement user authentication"
+paseo run --provider codex/gpt-5.4 --worktree feature-x "implement feature X"
+
+paseo ls                           # list running agents
+paseo attach abc123                # stream live output
+paseo send abc123 "also add tests" # follow-up task
+
+# run on a remote daemon
+paseo --host workstation.local:6767 run "run the full test suite"
+```
+
+See the [full CLI reference](https://paseo.sh/docs/cli) for more.
+
+## Orchestration skills (Unstable)
+
+Experimental skills that teach agents how to use the Paseo CLI to orchestrate other agents. I am updating these very frequently as I learn new things, expect changes without notice, might be coupled to my own setup, use at your own risk.
+
+```bash
+npx skills add getpaseo/paseo
+```
+
+Then use them in any agent conversation:
+
+```bash
+# Use handoff when you discuss something with an agent but want another one to implement.
+# I use this to plan with Claude and then handoff to Codex to implement.
+/paseo-handoff hand off the authentication fix to codex 5.4 in a worktree
+
+# Use loops when you have clear acceptance criteria (aka Ralph loops).
+/paseo-loop loop a codex agent to fix the backend tests, use sonnet to verify, max 10 iterations
+
+# Orchestrator teaches the agent how to create teams and manage them via a chat room.
+# Very opinionated and expects both Codex and Claude to work.
+/paseo-orchestrator spin up a team to implement the database refactor, use chat to coordinate. use claude to plan and codex to implement and review
+```
+
 ## Development
 
 Quick monorepo package map:
 - `packages/server`: Paseo daemon (agent process orchestration, WebSocket API, MCP server)
 - `packages/app`: Expo client (iOS, Android, web)
 - `packages/cli`: `paseo` CLI for daemon and agent workflows
-- `packages/desktop`: Tauri desktop app
+- `packages/desktop`: Electron desktop app
 - `packages/relay`: Relay package for remote connectivity
 - `packages/website`: Marketing site and documentation (`paseo.sh`)
 
@@ -49,12 +132,16 @@ npm run dev
 # run individual surfaces
 npm run dev:server
 npm run dev:app
+npm run dev:desktop
 npm run dev:website
 
+# build the daemon
+npm run build:daemon
+
 # repo-wide checks
 npm run typecheck
 ```
 
 ## License
 
-MIT
+AGPL-3.0

SECURITY.md

@@ -22,7 +22,7 @@ The relay is designed to be untrusted. All traffic between your phone and daemon
 1. The daemon generates a persistent ECDH keypair and stores it locally
 2. When you scan the QR code or click the pairing link, your phone receives the daemon's public key
 3. Your phone sends a handshake message with its own public key. The daemon will not accept any commands until this handshake completes.
-4. Both sides perform an ECDH key exchange to derive a shared secret. All subsequent messages are encrypted with AES-256-GCM.
+4. Both sides perform an ECDH key exchange to derive a shared secret. All subsequent messages are encrypted with XSalsa20-Poly1305 (NaCl box).
 
 The relay sees only: IP addresses, timing, message sizes, and session IDs. It cannot read message contents, forge messages, or derive encryption keys from observing the handshake.
 
@@ -31,14 +31,26 @@ The relay sees only: IP addresses, timing, message sizes, and session IDs. It ca
 The daemon requires a valid cryptographic handshake before processing any commands. A compromised relay cannot:
 
 - **Send commands** — Without your phone's private key, it cannot complete the handshake
-- **Read your traffic** — All messages are encrypted with AES-256-GCM after the handshake
-- **Forge messages** — GCM provides authenticated encryption; tampered messages are rejected
-- **Replay old messages** — Each session derives fresh encryption keys
+- **Read your traffic** — All messages are encrypted with XSalsa20-Poly1305 (NaCl box) after the handshake
+- **Forge messages** — NaCl box provides authenticated encryption; tampered messages are rejected
+- **Replay old messages across sessions** — Each session derives fresh encryption keys, so ciphertext from one session cannot be replayed into another session. Within a live session, replay protection is not yet implemented; the protocol uses random nonces and does not track nonce reuse or message counters.
 
 ### Trust model
 
 The QR code or pairing link is the trust anchor. It contains the daemon's public key, which is required to establish the encrypted connection. Treat it like a password — don't share it publicly.
 
+## Local daemon trust boundary
+
+By default, the daemon binds to `127.0.0.1`. The local control plane is trusted by network reachability, not by an additional authentication token.
+
+Anything that can reach the daemon socket can control the daemon. This is the same security model Docker documents for its daemon: the security boundary is access to the socket or listening address.
+
+If you expose the daemon beyond loopback, such as by binding to `0.0.0.0`, forwarding it through a tunnel or reverse proxy, or publishing it from a Docker container, you are responsible for restricting and securing that access.
+
+For remote access, use the relay connection. It is the supported path for reaching the daemon off-machine, and it adds end-to-end encryption plus a pairing handshake before commands are accepted.
+
+Host header validation and CORS origin checks are defense-in-depth controls for localhost exposure. They help block DNS rebinding and browser-based attacks, but they do not replace network isolation.
+
 ## DNS rebinding protection
 
 CORS is not a complete security boundary. It controls which browser origins can make requests, but does not prevent a malicious website from resolving its domain to your local machine (DNS rebinding).
@@ -51,4 +63,4 @@ Paseo wraps agent CLIs (Claude Code, Codex, OpenCode) but does not manage their
 
 ## Reporting vulnerabilities
 
-If you discover a security vulnerability, please report it privately by emailing mo@faro.so. Do not open a public issue.
+If you discover a security vulnerability, please report it privately by emailing hello@moboudra.com. Do not open a public issue.

biome.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.0.0/schema.json",
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "files": {
+    "includes": ["**", "!*.lock"]
+  },
+  "formatter": {
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "trailingCommas": "all",
+      "semicolons": "always"
+    }
+  },
+  "css": {
+    "parser": {
+      "cssModules": true,
+      "tailwindDirectives": true
+    }
+  },
+  "linter": {
+    "enabled": false
+  }
+}

docs/ANDROID.md

@@ -20,7 +20,7 @@ From repo root:
 ```bash
 npm run android:development    # Debug build
 npm run android:production     # Release build
-npm run android:clean          # Clean native project
+npm run android:clear          # Remove generated Android project
 ```
 
 Or from `packages/app`:
@@ -34,8 +34,8 @@ APP_VARIANT=development npx expo run:android --variant=debug
 APP_VARIANT=production npx expo prebuild --platform android --non-interactive
 APP_VARIANT=production npx expo run:android --variant=release
 
-# Clean
-npx expo prebuild --platform android --clean --non-interactive
+# Clear generated Android project
+rm -rf android
 ```
 
 ## Screenshots
@@ -46,11 +46,13 @@ adb exec-out screencap -p > screenshot.png
 
 ## Cloud build + submit (EAS)
 
-Tag pushes like `v0.1.0` trigger:
+Stable tag pushes like `v0.1.0` trigger:
 
 - `packages/app/.eas/workflows/release-mobile.yml` on Expo servers (iOS + Android build + submit)
 - `.github/workflows/android-apk-release.yml` on GitHub Actions (APK asset on GitHub Release)
 
+Release candidate tags like `v0.1.1-rc.1` only trigger the GitHub APK workflow. They publish a GitHub prerelease APK for testing and do not submit to the stores.
+
 ### Useful commands
 
 ```bash

docs/ARCHITECTURE.md

@@ -9,7 +9,7 @@ Your code never leaves your machine. Paseo is local-first.
 ```
 ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
 │  Mobile App  │    │     CLI     │    │ Desktop App │
-│   (Expo)     │    │ (Commander) │    │  (Tauri)    │
+│   (Expo)     │    │ (Commander) │    │ (Electron)  │
 └──────┬───────┘    └──────┬──────┘    └──────┬──────┘
        │                   │                  │
        │    WebSocket      │    WebSocket     │    Managed subprocess
@@ -31,6 +31,14 @@ Your code never leaves your machine. Paseo is local-first.
 └───────────┘ └────────┘ └──────────┘
 ```
 
+## Components at a glance
+
+- **Daemon:** Local server that spawns and manages agent processes and exposes the WebSocket API.
+- **App:** Cross-platform Expo client for iOS, Android, web, and the shared UI used by desktop.
+- **CLI:** Terminal interface for agent workflows that can also start and manage the daemon.
+- **Desktop app:** Electron wrapper around the web app that bundles and auto-manages its own daemon.
+- **Relay:** Optional encrypted bridge for remote access without opening ports directly.
+
 ## Packages
 
 ### `packages/server` — The daemon
@@ -90,9 +98,9 @@ Enables remote access when the daemon is behind a firewall.
 
 See [SECURITY.md](../SECURITY.md) for the full threat model.
 
-### `packages/desktop` — Desktop app (Tauri)
+### `packages/desktop` — Desktop app (Electron)
 
-Tauri wrapper for macOS, Linux, and Windows.
+Electron wrapper for macOS, Linux, and Windows.
 
 - Can spawn the daemon as a managed subprocess
 - Native file access for workspace integration
@@ -180,5 +188,5 @@ $PASEO_HOME/
 ## Deployment models
 
 1. **Local daemon** (default): `paseo daemon start` on `127.0.0.1:6767`
-2. **Managed desktop**: Tauri app spawns daemon as subprocess
+2. **Managed desktop**: Electron app spawns daemon as subprocess
 3. **Remote + relay**: Daemon behind firewall, relay bridges with E2E encryption

docs/DATA_MODEL.md

@@ -0,0 +1,428 @@
+# Data Model
+
+Paseo uses **file-based JSON persistence** instead of a traditional database. All data is validated at runtime with Zod schemas and written atomically (write to temp file, then rename). There are no migrations — schemas use optional fields with defaults for forward compatibility.
+
+All server-side stores live under `$PASEO_HOME` (defaults to `~/.paseo`).
+
+---
+
+## Directory layout
+
+```
+$PASEO_HOME/
+├── config.json                          # Daemon configuration
+├── agents/
+│   └── {project-dir}/
+│       └── {agentId}.json               # One file per agent
+├── schedules/
+│   └── {scheduleId}.json                # One file per schedule
+├── chat/
+│   └── rooms.json                       # All rooms + messages
+├── loops/
+│   └── loops.json                       # All loop records
+├── projects/
+│   ├── projects.json                    # Project registry
+│   └── workspaces.json                  # Workspace registry
+└── push-tokens.json                     # Expo push notification tokens
+```
+
+---
+
+## 1. Agent Record
+
+**Path:** `$PASEO_HOME/agents/{project-dir}/{agentId}.json`
+
+Each agent is stored as a separate JSON file, grouped by project directory.
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | UUID, primary key |
+| `provider` | `string` | Agent provider (`"claude"`, `"codex"`, `"opencode"`, etc.) |
+| `cwd` | `string` | Working directory the agent operates in |
+| `createdAt` | `string` (ISO 8601) | Creation timestamp |
+| `updatedAt` | `string` (ISO 8601) | Last update timestamp |
+| `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 `{}`) |
+| `lastStatus` | `AgentStatus` | One of: `"initializing"`, `"idle"`, `"running"`, `"error"`, `"closed"` |
+| `lastModeId` | `string?` | Last active mode ID |
+| `config` | `SerializableConfig?` | Agent session configuration (see below) |
+| `runtimeInfo` | `RuntimeInfo?` | Live runtime state (see below) |
+| `features` | `AgentFeature[]?` | Provider-reported features (toggles/selects) |
+| `persistence` | `PersistenceHandle?` | Handle for resuming sessions |
+| `requiresAttention` | `boolean?` | Whether the agent needs user attention |
+| `attentionReason` | `"finished" \| "error" \| "permission"?` | Why attention is needed |
+| `attentionTimestamp` | `string?` (ISO 8601) | When attention was flagged |
+| `internal` | `boolean?` | Whether this is a system-internal agent (loop workers, etc.) |
+| `archivedAt` | `string?` (ISO 8601) | Soft-delete timestamp |
+
+### Nested: SerializableConfig
+
+| Field | Type | Description |
+|---|---|---|
+| `title` | `string?` | Configured title |
+| `modeId` | `string?` | Configured mode |
+| `model` | `string?` | Configured model |
+| `thinkingOptionId` | `string?` | Thinking/reasoning level |
+| `featureValues` | `Record<string, unknown>?` | Feature preference overrides |
+| `extra` | `Record<string, any>?` | Provider-specific config |
+| `systemPrompt` | `string?` | Custom system prompt |
+| `mcpServers` | `Record<string, any>?` | MCP server configurations |
+
+### Nested: RuntimeInfo
+
+| Field | Type | Description |
+|---|---|---|
+| `provider` | `string` | Active provider |
+| `sessionId` | `string?` | Active session ID |
+| `model` | `string?` | Active model |
+| `thinkingOptionId` | `string?` | Active thinking option |
+| `modeId` | `string?` | Active mode |
+| `extra` | `Record<string, unknown>?` | Provider-specific runtime data |
+
+### Nested: PersistenceHandle
+
+| Field | Type | Description |
+|---|---|---|
+| `provider` | `string` | Provider that owns the session |
+| `sessionId` | `string` | Session ID for resumption |
+| `nativeHandle` | `any?` | Provider-specific handle (Codex thread ID, Claude resume token, etc.) |
+| `metadata` | `Record<string, any>?` | Extra metadata |
+
+### Nested: AgentFeature (discriminated union on `type`)
+
+**Toggle:**
+
+| Field | Type |
+|---|---|
+| `type` | `"toggle"` |
+| `id` | `string` |
+| `label` | `string` |
+| `description` | `string?` |
+| `tooltip` | `string?` |
+| `icon` | `string?` |
+| `value` | `boolean` |
+
+**Select:**
+
+| Field | Type |
+|---|---|
+| `type` | `"select"` |
+| `id` | `string` |
+| `label` | `string` |
+| `description` | `string?` |
+| `tooltip` | `string?` |
+| `icon` | `string?` |
+| `value` | `string?` |
+| `options` | `AgentSelectOption[]` |
+
+---
+
+## 2. Daemon Configuration
+
+**Path:** `$PASEO_HOME/config.json`
+
+Single file, validated with `PersistedConfigSchema`.
+
+```
+{
+  version: 1,
+  daemon: {
+    listen: "127.0.0.1:6767",
+    allowedHosts: true | string[],
+    mcp: { enabled: boolean },
+    cors: { allowedOrigins: string[] },
+    relay: { enabled: boolean, endpoint: string, publicEndpoint: string }
+  },
+  app: {
+    baseUrl: string
+  },
+  providers: {
+    openai: { apiKey: string },
+    local: { modelsDir: string }
+  },
+  agents: {
+    providers: {
+      [provider: string]: {
+        command: { mode: "default" } | { mode: "append", args: string[] } | { mode: "replace", argv: string[] },
+        env: Record<string, string>
+      }
+    }
+  },
+  features: {
+    dictation: { enabled, stt: { provider, model, confidenceThreshold } },
+    voiceMode: { enabled, llm, stt, turnDetection, tts: { provider, model, voice, speakerId, speed } }
+  },
+  log: {
+    level, format,
+    console: { level, format },
+    file: { level, path, rotate: { maxSize, maxFiles } }
+  }
+}
+```
+
+All fields are optional with sensible defaults.
+
+---
+
+## 3. Schedule
+
+**Path:** `$PASEO_HOME/schedules/{id}.json`
+
+One file per schedule. ID is 8 hex characters.
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | 8-char hex ID |
+| `name` | `string?` | Human-readable name |
+| `prompt` | `string` | The prompt to send |
+| `cadence` | `ScheduleCadence` | Timing (see below) |
+| `target` | `ScheduleTarget` | What to run (see below) |
+| `status` | `"active" \| "paused" \| "completed"` | Current state |
+| `createdAt` | `string` (ISO 8601) | |
+| `updatedAt` | `string` (ISO 8601) | |
+| `nextRunAt` | `string?` (ISO 8601) | Next scheduled execution |
+| `lastRunAt` | `string?` (ISO 8601) | Last execution time |
+| `pausedAt` | `string?` (ISO 8601) | When paused |
+| `expiresAt` | `string?` (ISO 8601) | Auto-expire time |
+| `maxRuns` | `number?` | Max executions before completing |
+| `runs` | `ScheduleRun[]` | Execution history |
+
+### Nested: ScheduleCadence (discriminated union on `type`)
+
+- `{ type: "every", everyMs: number }` — interval in milliseconds
+- `{ type: "cron", expression: string }` — cron expression
+
+### Nested: ScheduleTarget (discriminated union on `type`)
+
+- `{ type: "agent", agentId: string }` — send to existing agent
+- `{ type: "new-agent", config: { provider, cwd, modeId?, model?, thinkingOptionId?, title?, approvalPolicy?, sandboxMode?, networkAccess?, webSearch?, extra?, systemPrompt?, mcpServers? } }` — create a new agent
+
+### Nested: ScheduleRun
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | Run ID |
+| `scheduledFor` | `string` (ISO 8601) | Intended execution time |
+| `startedAt` | `string` (ISO 8601) | |
+| `endedAt` | `string?` (ISO 8601) | |
+| `status` | `"running" \| "succeeded" \| "failed"` | |
+| `agentId` | `string?` (UUID) | Agent used for this run |
+| `output` | `string?` | Agent output text |
+| `error` | `string?` | Error message if failed |
+
+---
+
+## 4. Chat
+
+**Path:** `$PASEO_HOME/chat/rooms.json`
+
+Single file containing all rooms and messages.
+
+```json
+{
+  "rooms": [ ... ],
+  "messages": [ ... ]
+}
+```
+
+### ChatRoom
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` (UUID) | |
+| `name` | `string` | Unique room name (case-insensitive) |
+| `purpose` | `string?` | Room description |
+| `createdAt` | `string` (ISO 8601) | |
+| `updatedAt` | `string` (ISO 8601) | Updated on each new message |
+
+### ChatMessage
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` (UUID) | |
+| `roomId` | `string` | FK to ChatRoom.id |
+| `authorAgentId` | `string` | Agent ID of the author |
+| `body` | `string` | Message text (supports `@mentions`) |
+| `replyToMessageId` | `string?` | FK to another ChatMessage.id |
+| `mentionAgentIds` | `string[]` | Extracted `@mention` agent IDs |
+| `createdAt` | `string` (ISO 8601) | |
+
+---
+
+## 5. Loop
+
+**Path:** `$PASEO_HOME/loops/loops.json`
+
+Single file containing an array of all loop records.
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | 8-char UUID prefix |
+| `name` | `string?` | Human-readable name |
+| `prompt` | `string` | Worker prompt |
+| `cwd` | `string` | Working directory |
+| `provider` | `string` | Default provider |
+| `model` | `string?` | Default model |
+| `workerProvider` | `string?` | Override provider for workers |
+| `workerModel` | `string?` | Override model for workers |
+| `verifierProvider` | `string?` | Override provider for verifiers |
+| `verifierModel` | `string?` | Override model for verifiers |
+| `verifyPrompt` | `string?` | LLM verification prompt |
+| `verifyChecks` | `string[]` | Shell commands to run as checks |
+| `archive` | `boolean` | Whether to archive worker agents after use |
+| `sleepMs` | `number` | Delay between iterations (ms) |
+| `maxIterations` | `number?` | Cap on iterations |
+| `maxTimeMs` | `number?` | Total time budget (ms) |
+| `status` | `"running" \| "succeeded" \| "failed" \| "stopped"` | |
+| `createdAt` | `string` (ISO 8601) | |
+| `updatedAt` | `string` (ISO 8601) | |
+| `startedAt` | `string` (ISO 8601) | |
+| `completedAt` | `string?` (ISO 8601) | |
+| `stopRequestedAt` | `string?` (ISO 8601) | |
+| `iterations` | `LoopIteration[]` | |
+| `logs` | `LoopLogEntry[]` | |
+| `nextLogSeq` | `number` | Monotonic log sequence counter |
+| `activeIteration` | `number?` | Currently executing iteration index |
+| `activeWorkerAgentId` | `string?` | Currently running worker agent |
+| `activeVerifierAgentId` | `string?` | Currently running verifier agent |
+
+### Nested: LoopIteration
+
+| Field | Type | Description |
+|---|---|---|
+| `index` | `number` | 1-based iteration index |
+| `workerAgentId` | `string?` | Agent ID of the worker |
+| `workerStartedAt` | `string` (ISO 8601) | |
+| `workerCompletedAt` | `string?` (ISO 8601) | |
+| `verifierAgentId` | `string?` | Agent ID of the verifier |
+| `status` | `"running" \| "succeeded" \| "failed" \| "stopped"` | |
+| `workerOutcome` | `"completed" \| "failed" \| "canceled"?` | |
+| `failureReason` | `string?` | |
+| `verifyChecks` | `LoopVerifyCheckResult[]` | Shell check results |
+| `verifyPrompt` | `LoopVerifyPromptResult?` | LLM verification result |
+
+### Nested: LoopLogEntry
+
+| Field | Type |
+|---|---|
+| `seq` | `number` (monotonic) |
+| `timestamp` | `string` (ISO 8601) |
+| `iteration` | `number?` |
+| `source` | `"loop" \| "worker" \| "verifier" \| "verify-check"` |
+| `level` | `"info" \| "error"` |
+| `text` | `string` |
+
+### Nested: LoopVerifyCheckResult
+
+| Field | Type |
+|---|---|
+| `command` | `string` |
+| `exitCode` | `number` |
+| `passed` | `boolean` |
+| `stdout` | `string` |
+| `stderr` | `string` |
+| `startedAt` | `string` (ISO 8601) |
+| `completedAt` | `string` (ISO 8601) |
+
+### Nested: LoopVerifyPromptResult
+
+| Field | Type |
+|---|---|
+| `passed` | `boolean` |
+| `reason` | `string` |
+| `verifierAgentId` | `string?` |
+| `startedAt` | `string` (ISO 8601) |
+| `completedAt` | `string` (ISO 8601) |
+
+---
+
+## 6. Project Registry
+
+**Path:** `$PASEO_HOME/projects/projects.json`
+
+Array of project records.
+
+| Field | Type | Description |
+|---|---|---|
+| `projectId` | `string` | Primary key |
+| `rootPath` | `string` | Filesystem root of the project |
+| `kind` | `"git" \| "non_git"` | |
+| `displayName` | `string` | |
+| `createdAt` | `string` (ISO 8601) | |
+| `updatedAt` | `string` (ISO 8601) | |
+| `archivedAt` | `string?` (ISO 8601) | Soft-delete timestamp |
+
+---
+
+## 7. Workspace Registry
+
+**Path:** `$PASEO_HOME/projects/workspaces.json`
+
+Array of workspace records. A workspace is a specific working directory within a project.
+
+| Field | Type | Description |
+|---|---|---|
+| `workspaceId` | `string` | Primary key |
+| `projectId` | `string` | FK to Project.projectId |
+| `cwd` | `string` | Filesystem path |
+| `kind` | `"local_checkout" \| "worktree" \| "directory"` | |
+| `displayName` | `string` | |
+| `createdAt` | `string` (ISO 8601) | |
+| `updatedAt` | `string` (ISO 8601) | |
+| `archivedAt` | `string?` (ISO 8601) | Soft-delete timestamp |
+
+---
+
+## 8. Push Token Store
+
+**Path:** `$PASEO_HOME/push-tokens.json`
+
+```json
+{
+  "tokens": ["ExponentPushToken[...]", ...]
+}
+```
+
+Simple set of Expo push notification tokens. No schema validation — just an array of strings.
+
+---
+
+## Client-side stores (App)
+
+These live in React Native `AsyncStorage` or browser `IndexedDB`, not on the daemon filesystem.
+
+### Draft Store
+
+**AsyncStorage key:** `paseo-drafts` (version 2)
+
+```typescript
+{
+  drafts: Record<draftKey, {
+    input: { text: string, images: AttachmentMetadata[] },
+    lifecycle: "active" | "abandoned" | "sent",
+    updatedAt: number,     // epoch ms
+    version: number        // optimistic concurrency
+  }>,
+  createModalDraft: DraftRecord | null
+}
+```
+
+### Attachment Store (Web)
+
+**IndexedDB database:** `paseo-attachment-bytes`, object store: `attachments`
+
+Stores binary attachment blobs keyed by attachment ID.
+
+### AttachmentMetadata
+
+| Field | Type | Description |
+|---|---|---|
+| `id` | `string` | Unique attachment ID |
+| `mimeType` | `string` | MIME type |
+| `storageType` | `string` | Storage backend identifier |
+| `storageKey` | `string` | Key within the storage backend |
+| `createdAt` | `number` | Epoch ms |
+| `fileName` | `string?` | Original filename |
+| `byteSize` | `number?` | Size in bytes |

docs/FILE_ICONS.md

@@ -0,0 +1,109 @@
+# File Icons
+
+The file explorer uses colored SVG icons from [`material-icon-theme`](https://github.com/material-extensions/vscode-material-icon-theme) (installed as a dev dependency in `packages/app`).
+
+Icons are inlined as SVG strings in:
+
+```
+packages/app/src/components/material-file-icons.ts
+```
+
+This file is auto-generated. Do not edit it by hand.
+
+## How it works
+
+- `SVG_ICONS` maps icon names (e.g. `"typescript"`) to raw SVG strings
+- `EXTENSION_TO_ICON` maps file extensions (e.g. `"ts"`) to icon names
+- `getFileIconSvg(fileName)` returns the SVG string for a given filename, falling back to a generic file icon
+
+## Adding a new icon
+
+1. Find the icon name in the material-icon-theme manifest:
+
+```bash
+node -e "
+const m = require('./node_modules/material-icon-theme/dist/material-icons.json');
+console.log('fileExtensions:', m.fileExtensions['YOUR_EXT']);
+console.log('languageIds:', m.languageIds['YOUR_LANG']);
+"
+```
+
+2. Verify the SVG exists:
+
+```bash
+cat node_modules/material-icon-theme/icons/ICON_NAME.svg
+```
+
+3. Add two things to `material-file-icons.ts`:
+
+   - The SVG string in `SVG_ICONS`:
+     ```ts
+     "icon_name": `<svg ...>...</svg>`,
+     ```
+
+   - The extension mapping in `EXTENSION_TO_ICON`:
+     ```ts
+     "ext": "icon_name",
+     ```
+
+4. Run `npm run typecheck` to verify.
+
+## Currently included icons
+
+53 unique icons covering these extensions:
+
+| Extension(s) | Icon |
+|---|---|
+| `ts` | typescript |
+| `tsx` | react_ts |
+| `js` | javascript |
+| `jsx` | react |
+| `py` | python |
+| `go` | go |
+| `rs` | rust |
+| `rb` | ruby |
+| `java` | java |
+| `kt` | kotlin |
+| `c` | c |
+| `cpp` | cpp |
+| `h` | h |
+| `hpp` | hpp |
+| `cs` | csharp |
+| `swift` | swift |
+| `dart` | dart |
+| `ex`, `exs` | elixir |
+| `erl` | erlang |
+| `hs` | haskell |
+| `clj` | clojure |
+| `scala` | scala |
+| `ml` | ocaml |
+| `r` | r |
+| `lua` | lua |
+| `zig` | zig |
+| `nix` | nix |
+| `php` | php |
+| `html` | html |
+| `css` | css |
+| `scss` | sass |
+| `less` | less |
+| `json` | json |
+| `yml`, `yaml` | yaml |
+| `xml` | xml |
+| `toml` | toml |
+| `md`, `markdown` | markdown |
+| `sql` | database |
+| `graphql`, `gql` | graphql |
+| `sh`, `bash` | console |
+| `tf` | terraform |
+| `hcl` | hcl |
+| `vue` | vue |
+| `svelte` | svelte |
+| `astro` | astro |
+| `wasm` | webassembly |
+| `svg` | svg |
+| `png`, `jpg`, `jpeg`, `gif`, `webp`, `ico` | image |
+| `txt` | document |
+| `conf`, `cfg`, `ini` | settings |
+| `lock` | lock |
+| `groovy` | groovy |
+| `gradle` | gradle |

docs/MOBILE_TESTING.md

@@ -0,0 +1,206 @@
+# Mobile Testing
+
+## Maestro
+
+Maestro flows live in `packages/app/maestro/`. Reusable sub-flows live in `packages/app/maestro/flows/`.
+
+Run a flow:
+
+```bash
+maestro test packages/app/maestro/my-flow.yaml
+```
+
+### Screenshots
+
+`takeScreenshot` writes to the **current working directory** — there's no way to configure the output path in the YAML. To keep screenshots out of the checkout, `cd` into a temp directory and use an absolute path for the flow:
+
+```bash
+FLOW="$(pwd)/packages/app/maestro/my-flow.yaml"
+mkdir -p /tmp/maestro-out
+cd /tmp/maestro-out && maestro test "$FLOW"
+```
+
+`packages/app/maestro/.gitignore` excludes `*.png` as a safety net.
+
+### Element targeting
+
+Use `testID` or `nativeID` on components, then target with `id:` in flows. Prefer this over text matching — text breaks on copy changes.
+
+```tsx
+// Component
+<Pressable testID="sidebar-sessions" onPress={onPress}>
+```
+
+```yaml
+# Flow
+- tapOn:
+    id: "sidebar-sessions"
+- assertVisible:
+    id: "sidebar-sessions"
+```
+
+### Conditional steps
+
+Use `runFlow:when:visible` for steps that should only execute when a specific element is on screen:
+
+```yaml
+- runFlow:
+    when:
+      visible:
+        id: "sidebar-sessions"
+    commands:
+      - swipe:
+          direction: LEFT
+          duration: 300
+```
+
+This is how `flows/dev-client.yaml` handles Expo dev client screens that only appear in dev builds.
+
+### Don't use launchApp against a running dev app
+
+`launchApp` kills and restarts the app, disrupting Expo dev client state and host connections. For flows that test against an already-running dev app, **omit launchApp entirely** — just interact with whatever is on screen.
+
+Use `launchApp` only in flows that need a clean start (e.g., onboarding tests).
+
+### Swipe gestures
+
+Use `start`/`end` with percentage coordinates for precise control:
+
+```yaml
+# Edge swipe from left to open sidebar
+- swipe:
+    start: "5%,50%"
+    end: "80%,50%"
+    duration: 300
+```
+
+`direction: RIGHT` is simpler but less precise — use it for generic swipes, use coordinates when the start position matters (edge gestures, avoiding specific UI regions).
+
+### Assertions
+
+`assertVisible` checks **actual screen visibility**, not just view tree presence. An element that exists in the tree but is off-screen (e.g., `translateX: -400`) will correctly fail `assertVisible`. This makes it reliable for catching animation bugs where state says "open" but the view is visually hidden.
+
+For async elements, use `extendedWaitUntil`:
+
+```yaml
+- extendedWaitUntil:
+    visible: ".*Online.*"
+    timeout: 90000
+```
+
+### Dev client handling
+
+Two reusable flows handle Expo dev client screens after launch:
+
+- `flows/launch.yaml` — handles dev launcher, dismisses dev menu, asserts "Welcome to Paseo"
+- `flows/dev-client.yaml` — same but without asserting a particular app route
+
+## Self-verification loops
+
+Maestro can only interact with the app UI — it can't toggle iOS appearance, change locale, or simulate network conditions. For bugs that depend on system-level state, wrap Maestro in a bash script that handles the system changes between Maestro runs.
+
+This pattern also lets agents self-verify fixes without manual user testing.
+
+### Pattern
+
+1. Run baseline Maestro flow (confirm feature works)
+2. Make system-level change via `xcrun simctl` (toggle appearance, etc.)
+3. Re-run Maestro flow (confirm feature still works)
+4. Repeat N iterations to catch intermittent failures
+
+Scripts run `maestro test` from inside a temp directory so screenshots don't dirty the checkout.
+
+See `packages/app/maestro/test-sidebar-theme.sh` for the canonical example:
+
+```bash
+bash packages/app/maestro/test-sidebar-theme.sh 6 1
+# Args: iterations=6, wait_seconds=1 between toggle and test
+```
+
+Key elements of the script pattern:
+
+```bash
+set -euo pipefail
+ITERATIONS="${1:-3}"
+
+for i in $(seq 1 "$ITERATIONS"); do
+  # Toggle system state
+  xcrun simctl ui booted appearance light
+
+  # Wait for change to propagate
+  sleep 1
+
+  # Run Maestro flow and capture result
+  if maestro test "$FLOW" 2>&1 | tee "$ITER_DIR/test.log"; then
+    echo "PASS"
+  else
+    echo "FAIL"
+    xcrun simctl io booted screenshot "$ITER_DIR/failure-state.png"
+  fi
+done
+```
+
+## Unistyles + Reanimated
+
+### The crash
+
+Applying Unistyles theme-reactive styles (`StyleSheet.create((theme) => ...)`) directly to `Animated.View` causes **"Unable to find node on an unmounted component"** on theme change.
+
+Unistyles wraps styled components in `<UnistylesComponent>` and patches native view properties via C++. Reanimated also manages the same native node for animated transforms. When the theme changes, both systems try to update the node simultaneously and the view crashes.
+
+### The fix
+
+Use plain React Native `StyleSheet.create` for static positioning on `Animated.View`. Pass theme-dependent values as inline styles from `useUnistyles()`:
+
+```tsx
+// BAD: Unistyles dynamic style on Animated.View
+const styles = StyleSheet.create((theme) => ({
+  sidebar: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    bottom: 0,
+    backgroundColor: theme.colors.surfaceSidebar, // theme-reactive
+    overflow: "hidden",
+  },
+}));
+
+<Animated.View style={[styles.sidebar, animatedStyle]} />
+```
+
+```tsx
+// GOOD: static stylesheet + inline theme values
+import { StyleSheet as RNStyleSheet } from "react-native";
+
+const staticStyles = RNStyleSheet.create({
+  sidebar: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    bottom: 0,
+    overflow: "hidden",
+  },
+});
+
+const { theme } = useUnistyles();
+
+<Animated.View
+  style={[staticStyles.sidebar, animatedStyle, { backgroundColor: theme.colors.surfaceSidebar }]}
+/>
+```
+
+Regular `View` components can safely use Unistyles dynamic styles — the conflict is specific to `Animated.View`.
+
+## iOS Simulator
+
+```bash
+# Screenshot
+xcrun simctl io booted screenshot /tmp/screenshot.png
+
+# Dark/light mode
+xcrun simctl ui booted appearance          # check current
+xcrun simctl ui booted appearance dark     # set dark
+xcrun simctl ui booted appearance light    # set light
+```
+
+Expo dev server logs are in the tmux pane running `npm run dev`. Daemon logs are at `$PASEO_HOME/daemon.log` (see [DEVELOPMENT.md](DEVELOPMENT.md)).

docs/PRODUCT.md

@@ -0,0 +1,74 @@
+# Product
+
+What Paseo is, who it's for, and where it's going.
+
+## What is Paseo
+
+Paseo is a next-generation development environment built around agents. One interface to run, monitor, and interact with coding agents across desktop, mobile, terminal, and web.
+
+The development workflow is shifting from manually editing files to orchestrating agents that do the editing. Paseo is built for that workflow.
+
+## Core philosophy
+
+Freedom and flexibility. Every design decision follows from this:
+
+- **Multi-provider** — Use any coding agent harness. Pick the right model for each job, switch freely as the landscape shifts. No vendor-lock in.
+- **Cross-device** — Desktop, mobile, web, CLI. Start work at your desk, check progress from your phone, script from the terminal.
+- **Self-hosted** — The daemon runs on your machine. Your code, your keys, your environment. No inference markup, no cloud dependency.
+- **Respectful** - No telemetry, no forced cloud, no forced accounts
+- **Open source** — AGPL-3.0. Users can inspect, fork, and contribute.
+- **BYOK** — Bring your own keys. Use your subsidized plans and first-party provider pricing. Paseo adds zero cost on top.
+
+## How it works
+
+### Projects and workspaces
+
+Projects are grouped in the sidebar, detected automatically from your filesystem and tagged by git remote when available.
+
+Each project opens as a workspace. For git projects, the default workspace is the main checkout. Users can create additional workspaces, which are isolated copies (git worktrees) where agents work without affecting main.
+
+### Inside a workspace
+
+A workspace is a flexible canvas:
+- Launch multiple agents side by side in split panes
+- Open terminals alongside agents
+- Mix and match providers within the same workspace
+
+### The daemon
+
+Paseo is a client-server system. The daemon (Node.js) runs on your machine, manages agent processes, and streams output in real time over WebSocket. Clients connect to the daemon — locally or remotely.
+
+This architecture means:
+- The daemon can run on any machine: laptop, VM, remote server
+- Multiple clients can connect simultaneously
+- Agents keep running when you close the app
+
+## Target user
+
+Anyone who builds software:
+
+- Care about owning their tools and their data
+- Use multiple AI providers and want to switch freely
+- Run agents on real tasks across real projects
+- Want to work from multiple devices
+
+## What compounds over time
+
+- **Trust** — Showing up daily, shipping in public, being open source. Earned slowly, lost quickly.
+- **Community contributions** — Code, packaging, skills, agent configs. Contributors become advocates.
+- **Ecosystem** — Skills, integrations, shared configs. Community-built content that makes the platform more valuable.
+
+## Strategic bets
+
+1. **Models commoditize.** Value moves to the orchestration layer. The best model changes monthly — the workflow layer stays.
+2. **Multi-provider wins.** No single provider stays on top. Developers want the best model for each task.
+3. **The daemon as infrastructure.** Server/client architecture enables deployment anywhere.
+4. **Open source outlasts funding.** Open source communities are resilient. Contributors become advocates.
+
+## Current state (March 2026)
+
+- Desktop (Electron), mobile (iOS/Android), web, CLI
+- Providers: Claude Code (Agent SDK), Codex (app-server), OpenCode
+- Daily releases
+- Community contributions starting (packaging, bug fixes)
+- Key UX: split panes, keybinding customization, workspace model

docs/PROVIDERS.md

@@ -0,0 +1,359 @@
+# Adding a New Provider to Paseo
+
+This guide walks through adding a new agent provider end-to-end. There are two integration patterns, and this doc covers both.
+
+## Two Integration Patterns
+
+### ACP (Agent Client Protocol) -- recommended
+
+Extend `ACPAgentClient`. The base class handles process spawning, stdio transport, session lifecycle, streaming, permissions, and model discovery. You provide configuration (command, modes, capabilities) and optionally override `isAvailable()` for auth checks.
+
+Existing ACP providers: `claude-acp`, `copilot`.
+
+### Direct
+
+Implement the `AgentClient` and `AgentSession` interfaces yourself. This gives full control but requires you to handle process management, streaming, permissions, and session persistence from scratch.
+
+Existing direct providers: `claude`, `codex`, `opencode`.
+
+---
+
+## ACP Provider Checklist
+
+### 1. Create the provider class
+
+Create `packages/server/src/server/agent/providers/{name}-agent.ts`.
+
+Define capabilities, modes, and a thin subclass of `ACPAgentClient`:
+
+```ts
+import type { Logger } from "pino";
+import type { AgentCapabilityFlags, AgentMode } from "../agent-sdk-types.js";
+import type { ProviderRuntimeSettings } from "../provider-launch-config.js";
+import { ACPAgentClient } from "./acp-agent.js";
+
+const MY_PROVIDER_CAPABILITIES: AgentCapabilityFlags = {
+  supportsStreaming: true,
+  supportsSessionPersistence: true,
+  supportsDynamicModes: true,
+  supportsMcpServers: true,
+  supportsReasoningStream: true,
+  supportsToolInvocations: true,
+};
+
+const MY_PROVIDER_MODES: AgentMode[] = [
+  {
+    id: "default",
+    label: "Default",
+    description: "Standard agent mode",
+  },
+  // Add more modes as needed
+];
+
+type MyProviderClientOptions = {
+  logger: Logger;
+  runtimeSettings?: ProviderRuntimeSettings;
+};
+
+export class MyProviderACPAgentClient extends ACPAgentClient {
+  constructor(options: MyProviderClientOptions) {
+    super({
+      provider: "my-provider",        // Must match the ID used everywhere else
+      logger: options.logger,
+      runtimeSettings: options.runtimeSettings,
+      defaultCommand: ["my-agent-binary", "--acp"],  // CLI command to spawn
+      defaultModes: MY_PROVIDER_MODES,
+      capabilities: MY_PROVIDER_CAPABILITIES,
+    });
+  }
+
+  // Override isAvailable() if the provider needs specific auth/env vars
+  override async isAvailable(): Promise<boolean> {
+    if (!(await super.isAvailable())) {
+      return false;  // Binary not found
+    }
+    return Boolean(process.env["MY_PROVIDER_API_KEY"]);
+  }
+}
+```
+
+The `super.isAvailable()` call checks that the binary from `defaultCommand` is on `$PATH`. Override only to add credential checks on top.
+
+For reference, here is how Copilot does it -- no auth override needed because the CLI handles auth itself:
+
+```ts
+export class CopilotACPAgentClient extends ACPAgentClient {
+  constructor(options: CopilotACPAgentClientOptions) {
+    super({
+      provider: "copilot",
+      logger: options.logger,
+      runtimeSettings: options.runtimeSettings,
+      defaultCommand: ["copilot", "--acp"],
+      defaultModes: COPILOT_MODES,
+      capabilities: COPILOT_CAPABILITIES,
+    });
+  }
+
+  override async isAvailable(): Promise<boolean> {
+    return super.isAvailable();
+  }
+}
+```
+
+### 2. Add to the provider manifest
+
+In `packages/server/src/server/agent/provider-manifest.ts`, add mode definitions with UI metadata (icons, color tiers) and a provider definition entry.
+
+First, define the modes with visual metadata:
+
+```ts
+const MY_PROVIDER_MODES: AgentProviderModeDefinition[] = [
+  {
+    id: "default",
+    label: "Default",
+    description: "Standard agent mode",
+    icon: "ShieldCheck",
+    colorTier: "safe",
+  },
+  {
+    id: "autonomous",
+    label: "Autonomous",
+    description: "Runs without prompting",
+    icon: "ShieldOff",
+    colorTier: "dangerous",
+  },
+];
+```
+
+Available `colorTier` values: `"safe"`, `"moderate"`, `"dangerous"`, `"planning"`.
+Available `icon` values: `"ShieldCheck"`, `"ShieldAlert"`, `"ShieldOff"`.
+
+Then add to the `AGENT_PROVIDER_DEFINITIONS` array:
+
+```ts
+export const AGENT_PROVIDER_DEFINITIONS: AgentProviderDefinition[] = [
+  // ... existing providers ...
+  {
+    id: "my-provider",
+    label: "My Provider",
+    description: "Short description of the provider",
+    defaultModeId: "default",
+    modes: MY_PROVIDER_MODES,
+    // Optional: enable voice
+    voice: {
+      enabled: true,
+      defaultModeId: "default",
+      defaultModel: "some-model",
+    },
+  },
+];
+```
+
+### 3. Add the factory to the provider registry
+
+In `packages/server/src/server/agent/provider-registry.ts`, import your class and add a factory entry:
+
+```ts
+import { MyProviderACPAgentClient } from "./providers/my-provider-agent.js";
+
+const PROVIDER_CLIENT_FACTORIES: Record<string, ProviderClientFactory> = {
+  // ... existing factories ...
+  "my-provider": (logger, runtimeSettings) =>
+    new MyProviderACPAgentClient({
+      logger,
+      runtimeSettings: runtimeSettings?.["my-provider"],
+    }),
+};
+```
+
+### 4. Add a provider icon (app)
+
+Create `packages/app/src/components/icons/my-provider-icon.tsx` following the pattern from existing icons (e.g., `claude-icon.tsx`):
+
+```tsx
+import Svg, { Path } from "react-native-svg";
+
+interface MyProviderIconProps {
+  size?: number;
+  color?: string;
+}
+
+export function MyProviderIcon({ size = 16, color = "currentColor" }: MyProviderIconProps) {
+  return (
+    <Svg width={size} height={size} viewBox="0 0 24 24" fill={color}>
+      <Path d="..." />
+    </Svg>
+  );
+}
+```
+
+Then register it in `packages/app/src/components/provider-icons.ts`:
+
+```ts
+import { MyProviderIcon } from "@/components/icons/my-provider-icon";
+
+const PROVIDER_ICONS: Record<string, typeof Bot> = {
+  claude: ClaudeIcon as unknown as typeof Bot,
+  codex: CodexIcon as unknown as typeof Bot,
+  "my-provider": MyProviderIcon as unknown as typeof Bot,
+};
+```
+
+If no icon is registered, the app falls back to a generic `Bot` icon from lucide.
+
+### 5. Add E2E test config
+
+In `packages/server/src/server/daemon-e2e/agent-configs.ts`, add your provider:
+
+```ts
+export const agentConfigs = {
+  // ... existing configs ...
+  "my-provider": {
+    provider: "my-provider",
+    model: "default-model-id",
+    modes: {
+      full: "autonomous",   // Mode with no permission prompts
+      ask: "default",       // Mode that requires permission approval
+    },
+  },
+} as const satisfies Record<string, AgentTestConfig>;
+```
+
+Add an availability check in `isProviderAvailable()`:
+
+```ts
+case "my-provider":
+  return (
+    isCommandAvailable("my-agent-binary") &&
+    Boolean(process.env.MY_PROVIDER_API_KEY)
+  );
+```
+
+Add to the `allProviders` array:
+
+```ts
+export const allProviders: AgentProvider[] = [
+  "claude",
+  "claude-acp",
+  "codex",
+  "copilot",
+  "opencode",
+  "my-provider",
+];
+```
+
+### 6. Run typecheck
+
+```bash
+npm run typecheck
+```
+
+This is required after every change per project rules.
+
+---
+
+## Direct Provider Checklist
+
+If your agent does not speak ACP, implement the interfaces from `agent-sdk-types.ts` directly.
+
+### Interfaces to implement
+
+**`AgentClient`** -- factory for sessions and model listing:
+
+```ts
+interface AgentClient {
+  readonly provider: AgentProvider;
+  readonly capabilities: AgentCapabilityFlags;
+  createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+  resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
+  listModels(options?: ListModelsOptions): Promise<AgentModelDefinition[]>;
+  isAvailable(): Promise<boolean>;
+  // Optional:
+  listPersistedAgents?(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+}
+```
+
+**`AgentSession`** -- a running agent conversation:
+
+```ts
+interface AgentSession {
+  readonly provider: AgentProvider;
+  readonly id: string | null;
+  readonly capabilities: AgentCapabilityFlags;
+  run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
+  startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{ turnId: string }>;
+  subscribe(callback: (event: AgentStreamEvent) => void): () => void;
+  streamHistory(): AsyncGenerator<AgentStreamEvent>;
+  getRuntimeInfo(): Promise<AgentRuntimeInfo>;
+  getAvailableModes(): Promise<AgentMode[]>;
+  getCurrentMode(): Promise<string | null>;
+  setMode(modeId: string): Promise<void>;
+  getPendingPermissions(): AgentPermissionRequest[];
+  respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;
+  describePersistence(): AgentPersistenceHandle | null;
+  interrupt(): Promise<void>;
+  close(): Promise<void>;
+  // Optional:
+  listCommands?(): Promise<AgentSlashCommand[]>;
+  setModel?(modelId: string | null): Promise<void>;
+  setThinkingOption?(thinkingOptionId: string | null): Promise<void>;
+}
+```
+
+### Steps
+
+1. Create `packages/server/src/server/agent/providers/{name}-agent.ts` implementing both interfaces
+2. Add to the provider manifest (same as ACP step 2 above)
+3. Add factory to the registry (same as ACP step 3 above)
+4. Add icon (same as ACP step 4 above)
+5. Add E2E config (same as ACP step 5 above)
+6. Run typecheck
+
+---
+
+## Testing
+
+### Manual testing with the CLI
+
+Start the daemon if not already running, then:
+
+```bash
+# Launch an agent with your provider
+paseo run --provider my-provider
+
+# Launch with a specific model and mode
+paseo run --provider my-provider --model some-model --mode default
+
+# List running agents
+paseo ls -a -g
+
+# Check if the provider reports models
+paseo models --provider my-provider
+```
+
+### E2E test patterns
+
+The E2E configs in `agent-configs.ts` expose two helpers:
+
+- `getFullAccessConfig(provider)` -- returns config for a session with no permission prompts
+- `getAskModeConfig(provider)` -- returns config for a session that triggers permission requests
+
+Tests use `isProviderAvailable(provider)` to skip when the binary or credentials are missing, so CI will not fail for providers that are not installed.
+
+---
+
+## Gotchas
+
+**Mode IDs can be URIs.** ACP providers like Copilot use full URIs as mode IDs (e.g., `"https://agentclientprotocol.com/protocol/session-modes#agent"`). Never assume mode IDs are simple strings. The manifest `defaultModeId` must match exactly.
+
+**Models and modes are discovered dynamically.** ACP providers report available models and modes at runtime via the protocol. The static definitions in `provider-manifest.ts` are used for UI scaffolding (icons, color tiers) but the runtime values from the agent process are the source of truth.
+
+**`AgentProvider` is always `string`.** The type alias is `type AgentProvider = string`. Provider IDs are validated against the manifest at runtime, not at the type level.
+
+**Auth patterns vary.** Some providers need API keys in env vars (`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`), some use OAuth tokens (`CLAUDE_CODE_OAUTH_TOKEN`), some use auth files (`~/.codex/auth.json`), and some handle auth entirely in their CLI binary (Copilot). Your `isAvailable()` method should check whatever is needed.
+
+**The manifest mode list and the agent class mode list are separate.** The manifest in `provider-manifest.ts` includes UI metadata (`icon`, `colorTier`). The agent class defines modes without UI metadata (just `id`, `label`, `description`). Keep them in sync.
+
+**`defaultCommand` is a tuple.** The first element is the binary name, the rest are default arguments. The base class uses this to find the executable and spawn the process.
+
+**Runtime settings can override the command.** Users can configure custom binary paths or environment variables per provider via `ProviderRuntimeSettings`. Your factory in the registry should pass `runtimeSettings?.["your-provider"]` through to the constructor.

docs/RELEASE.md

@@ -2,8 +2,21 @@
 
 All workspaces share one version and release together.
 
+## Two paths
+
+There are two supported ways to ship from `main`:
+
+1. **Direct stable release**: you are ready to ship the current `main` commit to everyone immediately.
+2. **Release candidate flow**: you want public test builds first, but you are not ready for the website, npm, or production mobile release flows to move yet.
+
 ## Standard release (patch)
 
+Before running any stable patch release command:
+
+- Make sure the intended release commit is already committed to `main` and the working tree is clean.
+- Make sure local `npm run typecheck` passes on that commit.
+- Do not use `npm run release:patch` as a substitute for checking whether the current commit is actually ready.
+
 ```bash
 npm run release:patch
 ```
@@ -12,37 +25,153 @@ This bumps the version across all workspaces, runs checks, publishes to npm, and
 
 If asked to "release paseo" without specifying major/minor, treat it as a patch release.
 
+Use the direct stable path when the current `main` changes are ready to become the public release immediately.
+
 ## Manual step-by-step
 
 ```bash
+npm run typecheck            # Verify the exact commit you intend to release
+npm run release:check        # Typecheck, build, dry-run pack
 npm run version:all:patch    # Bump version, create commit + tag
-npm run release:check        # Validate release
 npm run release:publish      # Publish to npm
 npm run release:push         # Push HEAD + tag (triggers CI workflows)
 ```
 
-## Draft release flow
+## Release candidate flow
 
 ```bash
-npm run draft-release:patch    # Bump, push tag, create draft GitHub Release
-npm run release:finalize       # Publish npm, promote draft to published
+npm run release:rc:patch       # Bump to X.Y.Z-rc.1, push commit + tag
+# ... test desktop and APK prerelease assets from GitHub Releases ...
+npm run release:rc:next        # Optional: cut X.Y.Z-rc.2, rc.3, ...
+npm run release:promote        # Promote X.Y.Z-rc.N to stable X.Y.Z
 ```
 
-- `draft-release:patch` creates the GitHub Release as a draft so desktop assets, APK uploads, and synced notes attach to it
-- `release:finalize` publishes npm and promotes the same draft release
-- Use the same semver tag for both; don't cut a second tag
+- RC tags are published GitHub prereleases like `v0.1.41-rc.1`
+- RCs publish desktop assets and APKs for testing, but they do not publish npm packages and do not trigger the production web/mobile release flows
+- `release:promote` creates a fresh stable tag like `v0.1.41`; the final release never reuses the RC tag
+- Desktop assets now come from the Electron package at `packages/desktop`
+- **Do NOT create a changelog entry for RCs.** The changelog remains stable-only. RC release notes are generated automatically so the website stays pinned to the latest published stable release.
+
+Use the RC path when you need to:
+
+- test a build manually in a Linux or Windows VM
+- send a build to a user who is hitting a specific problem
+- iterate on `rc.1`, `rc.2`, `rc.3`, and so on before deciding to ship broadly
+
+## Website behavior
+
+- The website download page points to GitHub's latest published **stable** release.
+- Published RC prereleases are public on GitHub Releases, but they do **not** become the website download target.
+- The website only moves when you publish the final stable release tag like `v0.1.41`.
+
+## Fixing a failed release build
+
+**NEVER bump the version to fix a build problem.** New versions are reserved for meaningful product changes (features, fixes, improvements). Build/CI failures are fixed on the current version.
+
+**Do not rely on `workflow_dispatch` for tagged code fixes.** The `workflow_dispatch` trigger runs the workflow file from the default branch but checks out the code at the tag ref (`ref: ${{ inputs.tag }}`). That means fixes committed to `main` won't change the tagged source tree being built. `workflow_dispatch` only helps when the fix lives in the workflow file itself.
+
+To retry a failed workflow, **always push a retry tag** on the commit you want to build. Reusing the same tag name is expected: move it with `git tag -f ...` and push it with `--force` so the workflow rebuilds the commit you actually want.
+
+Prefer a tag push over `workflow_dispatch` whenever you are rebuilding release code or release assets.
+
+The retry tag patterns below still work and remain the supported way to rebuild specific release targets:
+
+```bash
+# Desktop (all platforms)
+git tag -f desktop-v0.1.28 HEAD && git push origin desktop-v0.1.28 --force
+
+# Desktop (single platform)
+git tag -f desktop-macos-v0.1.28 HEAD && git push origin desktop-macos-v0.1.28 --force
+git tag -f desktop-linux-v0.1.28 HEAD && git push origin desktop-linux-v0.1.28 --force
+git tag -f desktop-windows-v0.1.28 HEAD && git push origin desktop-windows-v0.1.28 --force
+
+# Android APK
+git tag -f android-v0.1.28 HEAD && git push origin android-v0.1.28 --force
+
+# RC
+git tag -f v0.1.29-rc.2 HEAD && git push origin v0.1.29-rc.2 --force
+```
+
+This ensures the checkout ref matches the actual code on `main` with the fix included.
+
+- `vX.Y.Z` or `vX.Y.Z-rc.N` rebuilds the full tagged release
+- `desktop-vX.Y.Z` rebuilds desktop for all desktop platforms only
+- `desktop-macos-vX.Y.Z`, `desktop-linux-vX.Y.Z`, and `desktop-windows-vX.Y.Z` rebuild only that desktop platform
+- `android-vX.Y.Z` rebuilds the Android APK release only
 
 ## Notes
 
 - `version:all:*` bumps root + syncs workspace versions and `@getpaseo/*` dependency versions
 - `release:prepare` refreshes workspace `node_modules` links to prevent stale types
+- `npm run dev:desktop` and `npm run build:desktop` target the Electron desktop package in `packages/desktop`
 - If `release:publish` partially fails, re-run it — npm skips already-published versions
-- Website Mac download CTA URL derives from `packages/website/package.json` version at build time
+- The website uses GitHub's latest published release API for download links, so published RC prereleases do not replace the stable download target.
+
+## Changelog format
+
+Stable release notes depend on the changelog heading format. The heading **must** be strictly followed:
+
+```
+## X.Y.Z - YYYY-MM-DD
+```
+
+No prefix (`v`), no extra text. The parser matches the first `## X.Y.Z` line to extract the version. A malformed heading will break download links on the homepage.
+
+## Changelog policy
+
+- `CHANGELOG.md` is for **final stable releases only**.
+- Do not add or edit changelog entries while iterating on RCs.
+- Write the proper changelog entry when you are cutting the final stable release that comes after the RC cycle.
+- Between stable releases, keep changelog work out of the repo until the final release is ready.
+
+## Changelog ownership
+
+- **Only Claude should write changelog entries.**
+- If you are Codex and a stable release needs a changelog entry, launch a Claude agent with Paseo to draft it, then review and commit the result.
+
+## Changelog voice
+
+The changelog is shown on the Paseo homepage. Write it for **end users**, not developers.
+
+- **Frame everything from the user's perspective.** Describe what changed in the app, not what changed in the code. Users care that "workspaces load instantly" — not that a component no longer remounts.
+- **Never mention component names, internal modules, or implementation details.** No `WorkingIndicator`, no `accumulatedUsage`, no `reconcileAndEmitWorkspaceUpdates`.
+- **Collapse internal iterations.** If a feature was added and then fixed within the same release, just list the feature as working. Users never saw the broken version.
+- **Only list changes relative to the previous stable release.** The diff is `v(previous)..HEAD`. If something was introduced and fixed between those two tags, it never shipped — don't mention the fix.
+- **Cut low-signal entries.** "Toolbar buttons have consistent sizing" is too granular. Combine small polish items or drop them.
+
+## Pre-release sanity check
+
+Before cutting any release (RC or stable), run a Codex review of the diff as a last line of defence against shipping bugs.
+
+Load the `paseo` skill and launch a **Codex 5.4** agent with a prompt like:
+
+> Review the diff between the latest release tag and HEAD. Focus on:
+>
+> 1. **Breaking changes** — especially in the WebSocket protocol, agent lifecycle, and any server↔client contract.
+> 2. **Backward compatibility** — the important direction is old app clients talking to newly updated daemons. Users update desktop and daemon first, then keep running the old app for a while. Flag anything that breaks old clients against new daemons or requires both sides to update in lockstep.
+> 3. **Regressions** — anything that looks like it could break existing functionality.
+>
+> Diff: `git diff <latest-release-tag>..HEAD`
+
+The agent's job is a deep sanity check, not a full code review. If it flags anything, investigate before proceeding.
+
+## Changelog scope
+
+The changelog always covers **stable-to-HEAD**:
+
+- **RC release**: the diff and release notes cover `latest stable tag → HEAD`. RC release notes are auto-generated and not added to `CHANGELOG.md`.
+- **Stable release**: the diff and changelog entry cover `latest stable tag → HEAD`. Any intermediate RCs are skipped — the changelog captures the full delta from the previous stable release, not just what changed since the last RC.
+
+In other words, RCs are checkpoints along the way; the changelog only records the final jump from one stable version to the next.
 
 ## Completion checklist
 
+- [ ] Run the pre-release sanity check (see above) and address any findings
+- [ ] Ensure the intended release commit is already committed and the git worktree is clean before running any `release:*` patch/promote command
+- [ ] Ensure local `npm run typecheck` passes on that exact commit before running any `release:*` patch/promote command
 - [ ] Update `CHANGELOG.md` with user-facing release notes (features, fixes — not refactors)
-- [ ] `npm run release:patch` completes successfully
+- [ ] Verify the changelog heading follows strict `## X.Y.Z - YYYY-MM-DD` format
+- [ ] `npm run release:patch` or `npm run release:promote` completes successfully
 - [ ] GitHub `Desktop Release` workflow for the `v*` tag is green
 - [ ] GitHub `Android APK Release` workflow for the same tag is green
 - [ ] EAS `release-mobile.yml` workflow for the same tag is green

docs/plan-approval-normalization.md

@@ -0,0 +1,68 @@
+# Plan Approval Normalization
+
+## Goal
+
+Normalize plan approval across providers so the UI renders one consistent plan approval card and action row, while each provider keeps its own execution quirks behind the session permission interface.
+
+## Compatibility Constraints
+
+- Older clients must remain compatible with newer daemons.
+- All new wire fields must be optional.
+- Existing plan permissions without action metadata must still render and work.
+- Existing question permissions must keep their current behavior.
+
+## Design
+
+### Shared abstraction
+
+Add optional permission action definitions to the shared permission request/response types.
+
+- Permission requests may include `actions`.
+- Permission responses may include `selectedActionId`.
+- `kind: "plan"` remains the normalized concept for plan approval.
+- The UI renders actions from the permission request instead of hardcoding provider-specific buttons.
+
+### Claude
+
+Keep Claude's plan permission flow, but enrich it with explicit action definitions.
+
+- Always expose `Reject`.
+- Always expose `Implement`.
+- If the agent entered plan mode from a more permissive mode like `bypassPermissions`, also expose `Implement with <previous mode>`.
+- Resolve the selected action entirely inside `respondToPermission()`.
+
+### Codex
+
+Synthesize a normalized `kind: "plan"` permission after a Codex plan-mode turn completes with a plan result.
+
+- Emit a plan permission with `Reject` and `Implement` actions.
+- On `Implement`, disable `plan_mode`, disable `fast_mode`, and automatically start a follow-up implementation turn.
+- On `Reject`, resolve without starting a follow-up turn.
+- Keep the implementation prompt and state transitions inside the Codex provider.
+
+### Manager and state sync
+
+After permission resolution, refresh provider-derived state so the UI sees internal mode/feature changes without knowing provider quirks.
+
+- Refresh current mode
+- Refresh pending permissions
+- Refresh runtime info
+- Refresh features
+- Persist refreshed state
+
+### UI
+
+Render plan permissions through the existing plan card, but generate buttons from normalized permission actions.
+
+- If `actions` are absent, fall back to legacy buttons.
+- Plan cards should use `Implement` as the default primary label.
+- Do not add provider-specific rendering branches.
+
+## Verification
+
+1. Shared schema/type tests for optional `actions` and `selectedActionId`
+2. App tests for generic plan-action rendering
+3. Claude tests for third action when resuming from a more permissive mode
+4. Codex tests for synthetic plan approval and automatic implementation follow-up
+5. Manager tests for post-permission state refresh
+6. `npm run typecheck`

flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1772963539,
+        "narHash": "sha256-9jVDGZnvCckTGdYT53d/EfznygLskyLQXYwJLKMPsZs=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "9dcb002ca1690658be4a04645215baea8b95f31d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,59 @@
+{
+  description = "Paseo - self-hosted daemon for AI coding agents";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+    }:
+    let
+      supportedSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
+      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+      pkgsFor = system: import nixpkgs { inherit system; };
+    in
+    {
+      packages = forAllSystems (
+        system:
+        let
+          pkgs = pkgsFor system;
+          paseo = pkgs.callPackage ./nix/package.nix { };
+        in
+        {
+          default = paseo;
+          paseo = paseo;
+        }
+      );
+
+      nixosModules.default = self.nixosModules.paseo;
+      nixosModules.paseo =
+        { pkgs, lib, ... }:
+        {
+          imports = [ ./nix/module.nix ];
+          services.paseo.package = lib.mkDefault self.packages.${pkgs.stdenv.hostPlatform.system}.default;
+        };
+
+      devShells = forAllSystems (
+        system:
+        let
+          pkgs = pkgsFor system;
+        in
+        {
+          default = pkgs.mkShell {
+            packages = [
+              pkgs.nodejs_22
+              pkgs.python3
+            ];
+          };
+        }
+      );
+    };
+}

nix/module.nix

@@ -0,0 +1,172 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}:
+
+let
+  cfg = config.services.paseo;
+in
+{
+  options.services.paseo = {
+    enable = lib.mkEnableOption "Paseo, a self-hosted daemon for AI coding agents";
+
+    package = lib.mkPackageOption pkgs "paseo" { };
+
+    user = lib.mkOption {
+      type = lib.types.str;
+      default = "paseo";
+      description = "User account under which Paseo runs.";
+    };
+
+    group = lib.mkOption {
+      type = lib.types.str;
+      default = "paseo";
+      description = "Group under which Paseo runs.";
+    };
+
+    dataDir = lib.mkOption {
+      type = lib.types.str;
+      default =
+        if cfg.user == "paseo"
+        then "/var/lib/paseo"
+        else "/home/${cfg.user}/.paseo";
+      defaultText = lib.literalExpression ''
+        if cfg.user == "paseo"
+        then "/var/lib/paseo"
+        else "/home/''${cfg.user}/.paseo"
+      '';
+      description = "Directory for Paseo state (PASEO_HOME). Stores agent data, config, and logs.";
+    };
+
+    port = lib.mkOption {
+      type = lib.types.port;
+      default = 6767;
+      description = "Port for the Paseo daemon to listen on.";
+    };
+
+    listenAddress = lib.mkOption {
+      type = lib.types.str;
+      default = "127.0.0.1";
+      description = "Address for the Paseo daemon to bind to.";
+    };
+
+    openFirewall = lib.mkOption {
+      type = lib.types.bool;
+      default = false;
+      description = "Whether to open the firewall for the Paseo daemon port.";
+    };
+
+    allowedHosts = lib.mkOption {
+      type = lib.types.either (lib.types.enum [ true ]) (lib.types.listOf lib.types.str);
+      default = [ ];
+      example = [ ".example.com" "myhost.local" ];
+      description = ''
+        Hosts allowed to connect to the Paseo daemon (DNS rebinding protection).
+        Localhost and IP addresses are always allowed by default.
+
+        Use a leading dot to match a domain and all its subdomains
+        (e.g. `".example.com"` matches `example.com` and `foo.example.com`).
+
+        Set to `true` to allow any host (not recommended).
+      '';
+    };
+
+    relay = {
+      enable = lib.mkOption {
+        type = lib.types.bool;
+        default = true;
+        description = "Whether to enable the relay connection for remote access via app.paseo.sh.";
+      };
+    };
+
+    inheritUserEnvironment = lib.mkOption {
+      type = lib.types.bool;
+      default = cfg.user != "paseo";
+      defaultText = lib.literalExpression ''cfg.user != "paseo"'';
+      description = ''
+        Whether to include the user's profile PATH in the service environment.
+
+        When Paseo runs as a real user (not the default system user), AI agents
+        need access to the user's tools (git, ssh, etc.). This adds the user's
+        NixOS profile and system paths so agents can use them without manually
+        setting PATH.
+
+        Enabled by default when `user` is set to a non-default value.
+      '';
+    };
+
+    environment = lib.mkOption {
+      type = lib.types.attrsOf lib.types.str;
+      default = { };
+      example = lib.literalExpression ''
+        {
+          PASEO_RELAY_ENDPOINT = "relay.paseo.sh:443";
+        }
+      '';
+      description = "Extra environment variables for the Paseo daemon.";
+    };
+  };
+
+  config = lib.mkIf cfg.enable {
+    users.users.${cfg.user} = lib.mkIf (cfg.user == "paseo") {
+      isSystemUser = true;
+      group = cfg.group;
+      home = cfg.dataDir;
+    };
+
+    users.groups.${cfg.group} = lib.mkIf (cfg.group == "paseo") { };
+
+    systemd.tmpfiles.rules = [
+      "d ${cfg.dataDir} 0700 ${cfg.user} ${cfg.group} - -"
+    ];
+
+    systemd.services.paseo = {
+      description = "Paseo - self-hosted daemon for AI coding agents";
+      after = [ "network.target" ];
+      wantedBy = [ "multi-user.target" ];
+
+      environment = {
+        NODE_ENV = "production";
+        PASEO_HOME = cfg.dataDir;
+        PASEO_LISTEN = "${cfg.listenAddress}:${toString cfg.port}";
+      } // lib.optionalAttrs cfg.inheritUserEnvironment {
+        # mkForce overrides the default PATH from NixOS's systemd module (which
+        # only includes store paths for coreutils/grep/sed/systemd). Our PATH
+        # includes /run/current-system/sw/bin which is a superset of those.
+        PATH = lib.mkForce (lib.concatStringsSep ":" [
+          "/etc/profiles/per-user/${cfg.user}/bin"
+          "/run/current-system/sw/bin"
+          "/run/wrappers/bin"
+          "/nix/var/nix/profiles/default/bin"
+        ]);
+      } // lib.optionalAttrs (cfg.allowedHosts == true) {
+        PASEO_ALLOWED_HOSTS = "true";
+      } // lib.optionalAttrs (lib.isList cfg.allowedHosts && cfg.allowedHosts != [ ]) {
+        PASEO_ALLOWED_HOSTS = lib.concatStringsSep "," cfg.allowedHosts;
+      } // cfg.environment;
+
+      serviceConfig = {
+        Type = "simple";
+        User = cfg.user;
+        Group = cfg.group;
+
+        ExecStart =
+          "${cfg.package}/bin/paseo-server"
+          + lib.optionalString (!cfg.relay.enable) " --no-relay";
+
+        Restart = "on-failure";
+        RestartSec = 5;
+
+        # Graceful shutdown (server handles SIGTERM with a 10s timeout)
+        KillSignal = "SIGTERM";
+        TimeoutStopSec = 15;
+      };
+    };
+
+    environment.systemPackages = [ cfg.package ];
+
+    networking.firewall.allowedTCPPorts = lib.mkIf cfg.openFirewall [ cfg.port ];
+  };
+}

nix/package.nix

@@ -0,0 +1,144 @@
+{
+  lib,
+  stdenv,
+  buildNpmPackage,
+  nodejs_22,
+  python3,
+  makeWrapper,
+  # node-pty needs libuv headers on Linux
+  libuv,
+}:
+
+buildNpmPackage rec {
+  pname = "paseo";
+  version = (builtins.fromJSON (builtins.readFile ../package.json)).version;
+
+  src = lib.cleanSourceWith {
+    src = ./..;
+    filter = path: type:
+      let
+        baseName = builtins.baseNameOf path;
+        relPath = lib.removePrefix (toString ./..) path;
+      in
+      # Exclude non-daemon workspace contents (keep package.json for workspace resolution)
+      !(lib.hasPrefix "/packages/app/src" relPath)
+      && !(lib.hasPrefix "/packages/app/assets" relPath)
+      && !(lib.hasPrefix "/packages/app/android" relPath)
+      && !(lib.hasPrefix "/packages/app/ios" relPath)
+      && !(lib.hasPrefix "/packages/website/src" relPath)
+      && !(lib.hasPrefix "/packages/website/public" relPath)
+      && !(lib.hasPrefix "/packages/desktop/src" relPath)
+      && !(lib.hasPrefix "/packages/desktop/src-tauri" relPath)
+      # Exclude test fixtures and debug files
+      && !(lib.hasSuffix ".test.ts" baseName)
+      && !(lib.hasSuffix ".e2e.test.ts" baseName)
+      && baseName != "node_modules"
+      && baseName != ".git"
+      && baseName != ".paseo"
+      && baseName != ".DS_Store";
+  };
+
+  nodejs = nodejs_22;
+
+  # To update: run `nix build` with lib.fakeHash, copy the `got:` hash.
+  # CI auto-updates this when package-lock.json changes (see .github/workflows/).
+  npmDepsHash = "sha256-0VEwgqUn0j2YWofW8IB5SNpo7Vp3Znfz1TMDAnZFkzs=";
+
+  # Prevent onnxruntime-node's install script from running during automatic
+  # npm rebuild (it tries to download from api.nuget.org, which fails in the sandbox).
+  # We manually rebuild only node-pty in buildPhase.
+  npmRebuildFlags = [ "--ignore-scripts" ];
+
+  nativeBuildInputs = [
+    python3 # for node-gyp (node-pty compilation)
+    makeWrapper
+  ];
+
+  buildInputs = lib.optionals stdenv.hostPlatform.isLinux [
+    libuv
+  ];
+
+  # Don't use the default npm build hook — we need a custom build sequence
+  dontNpmBuild = true;
+
+  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.
+    npm rebuild node-pty
+
+    # Build all daemon packages in dependency order (defined in package.json)
+    npm run build:daemon
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/lib/paseo
+
+    # Copy root package metadata
+    cp package.json $out/lib/paseo/
+
+    # Copy node_modules (preserving workspace symlinks)
+    cp -a node_modules $out/lib/paseo/
+
+    # Auto-detect which @getpaseo/* packages were built by build:daemon
+    # (they'll have a dist/ directory). Copy those and remove the rest.
+    for link in $out/lib/paseo/node_modules/@getpaseo/*; do
+      name=$(basename "$link")
+      if [ -d "packages/$name/dist" ]; then
+        mkdir -p "$out/lib/paseo/packages/$name"
+        cp "packages/$name/package.json" "$out/lib/paseo/packages/$name/"
+        cp -a "packages/$name/dist" "$out/lib/paseo/packages/$name/"
+        if [ -d "packages/$name/node_modules" ]; then
+          cp -a "packages/$name/node_modules" "$out/lib/paseo/packages/$name/"
+        fi
+      else
+        rm -f "$link"
+      fi
+    done
+
+    # Copy CLI bin entry
+    mkdir -p $out/lib/paseo/packages/cli/bin
+    cp packages/cli/bin/paseo $out/lib/paseo/packages/cli/bin/
+
+    # Copy extra server files referenced at runtime
+    for f in agent-prompt.md .env.example; do
+      if [ -f packages/server/$f ]; then
+        cp packages/server/$f $out/lib/paseo/packages/server/
+      fi
+    done
+
+    # Copy server scripts (including supervisor-entrypoint) needed by CLI
+    if [ -d packages/server/dist/scripts ]; then
+      mkdir -p $out/lib/paseo/packages/server/dist/scripts
+      cp -a packages/server/dist/scripts/* $out/lib/paseo/packages/server/dist/scripts/
+    fi
+
+    # Create wrapper for the server entry point (for systemd / direct use)
+    mkdir -p $out/bin
+    makeWrapper ${nodejs}/bin/node $out/bin/paseo-server \
+      --add-flags "$out/lib/paseo/packages/server/dist/server/server/index.js" \
+      --set NODE_ENV production
+
+    # Create wrapper for the CLI
+    makeWrapper ${nodejs}/bin/node $out/bin/paseo \
+      --add-flags "$out/lib/paseo/packages/cli/dist/index.js" \
+      --set NODE_PATH "$out/lib/paseo/node_modules"
+
+    runHook postInstall
+  '';
+
+  meta = {
+    description = "Self-hosted daemon for Claude Code, Codex, and OpenCode";
+    homepage = "https://github.com/getpaseo/paseo";
+    license = lib.licenses.agpl3Plus;
+    mainProgram = "paseo";
+    platforms = lib.platforms.linux ++ lib.platforms.darwin;
+  };
+}

package.json

@@ -1,8 +1,10 @@
 {
   "name": "paseo",
-  "version": "0.1.27",
+  "version": "0.1.53",
   "private": true,
   "workspaces": [
+    "packages/expo-two-way-audio",
+    "packages/highlight",
     "packages/server",
     "packages/app",
     "packages/relay",
@@ -12,22 +14,24 @@
   ],
   "scripts": {
     "dev": "./scripts/dev.sh",
-    "dev:server": "NODE_ENV=development tsx packages/server/scripts/daemon-runner.ts --dev",
+    "dev:server": "npm run dev --workspace=@getpaseo/server",
     "dev:app": "npm run start --workspace=@getpaseo/app",
     "dev:website": "npm run dev --workspace=@getpaseo/website",
     "postinstall": "node scripts/postinstall-patches.mjs",
     "build": "npm run build --workspaces --if-present",
-    "build:daemon": "npm run build --workspace=@getpaseo/relay && npm run build --workspace=@getpaseo/server && npm run build --workspace=@getpaseo/cli",
+    "build:highlight": "npm run build --workspace=@getpaseo/highlight",
+    "build:daemon": "npm run build --workspace=@getpaseo/highlight && npm run build --workspace=@getpaseo/relay && npm run build --workspace=@getpaseo/server && npm run build --workspace=@getpaseo/cli",
     "typecheck": "npm run typecheck --workspaces --if-present",
     "typecheck:daemon": "npm run typecheck --workspace=@getpaseo/relay && npm run typecheck --workspace=@getpaseo/server && npm run typecheck --workspace=@getpaseo/cli",
     "test": "npm run test --workspaces --if-present",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
     "start": "npm run start --workspace=@getpaseo/server",
     "android": "npm run android --workspace=@getpaseo/app",
     "android:development": "npm run android:development --workspace=@getpaseo/app",
     "android:production": "npm run android:production --workspace=@getpaseo/app",
     "android:release": "npm run android:production --workspace=@getpaseo/app",
+    "android:clear": "npm run android:clear --workspace=@getpaseo/app",
     "android:clean": "npm run android:clean --workspace=@getpaseo/app",
     "ios": "npm run ios --workspace=@getpaseo/app",
     "web": "npm run web --workspace=@getpaseo/app",
@@ -37,31 +41,39 @@
     "version": "npm run version:sync-internal && npm run release:prepare && git add -A",
     "version:sync-internal": "node scripts/sync-workspace-versions.mjs",
     "release:prepare": "npm install --workspaces --include-workspace-root",
-    "version:all:patch": "npm version patch --include-workspace-root --message \"chore(release): cut %s\"",
-    "version:all:minor": "npm version minor --include-workspace-root --message \"chore(release): cut %s\"",
-    "version:all:major": "npm version major --include-workspace-root --message \"chore(release): cut %s\"",
-    "release:check": "npm run release:prepare && npm run typecheck --workspace=@getpaseo/relay && npm run typecheck --workspace=@getpaseo/server && npm run typecheck --workspace=@getpaseo/cli && npm run build --workspace=@getpaseo/relay && npm run build --workspace=@getpaseo/server && npm run build --workspace=@getpaseo/cli && npm pack --dry-run --workspace=@getpaseo/relay && npm pack --dry-run --workspace=@getpaseo/server && npm pack --dry-run --workspace=@getpaseo/cli",
-    "release:publish:dry-run": "npm publish --dry-run --workspace=@getpaseo/relay --access public && npm publish --dry-run --workspace=@getpaseo/server --access public && npm publish --dry-run --workspace=@getpaseo/cli --access public",
-    "release:publish": "npm publish --workspace=@getpaseo/relay --access public && npm publish --workspace=@getpaseo/server --access public && npm publish --workspace=@getpaseo/cli --access public",
+    "version:all:patch": "node scripts/set-release-version.mjs --mode patch",
+    "version:all:minor": "node scripts/set-release-version.mjs --mode minor",
+    "version:all:major": "node scripts/set-release-version.mjs --mode major",
+    "version:all:rc:patch": "node scripts/set-release-version.mjs --mode rc-patch",
+    "version:all:rc:minor": "node scripts/set-release-version.mjs --mode rc-minor",
+    "version:all:rc:major": "node scripts/set-release-version.mjs --mode rc-major",
+    "version:all:rc:next": "node scripts/set-release-version.mjs --mode rc-next",
+    "version:all:promote": "node scripts/set-release-version.mjs --mode promote",
+    "release:check": "npm run release:prepare && npm run typecheck --workspace=@getpaseo/highlight && npm run build --workspace=@getpaseo/highlight && npm run typecheck --workspace=@getpaseo/relay && npm run build --workspace=@getpaseo/relay && npm run typecheck --workspace=@getpaseo/server && npm run build --workspace=@getpaseo/server && npm run typecheck --workspace=@getpaseo/cli && npm run build --workspace=@getpaseo/cli && npm pack --dry-run --workspace=@getpaseo/highlight && npm pack --dry-run --workspace=@getpaseo/relay && npm pack --dry-run --workspace=@getpaseo/server && npm pack --dry-run --workspace=@getpaseo/cli",
+    "release:publish:dry-run": "npm publish --dry-run --workspace=@getpaseo/highlight --access public && npm publish --dry-run --workspace=@getpaseo/relay --access public && npm publish --dry-run --workspace=@getpaseo/server --access public && npm publish --dry-run --workspace=@getpaseo/cli --access public",
+    "release:publish": "npm publish --workspace=@getpaseo/highlight --access public && npm publish --workspace=@getpaseo/relay --access public && npm publish --workspace=@getpaseo/server --access public && npm publish --workspace=@getpaseo/cli --access public",
     "release:push": "node scripts/push-current-release-tag.mjs",
-    "draft-release:push": "node scripts/push-current-release-tag.mjs --draft-release",
-    "draft-release:patch": "npm run version:all:patch && npm run release:check && npm run draft-release:push",
-    "draft-release:minor": "npm run version:all:minor && npm run release:check && npm run draft-release:push",
-    "draft-release:major": "npm run version:all:major && npm run release:check && npm run draft-release:push",
-    "release:finalize": "node scripts/finalize-current-release.mjs",
-    "release:patch": "npm run version:all:patch && npm run release:check && npm run release:publish && npm run release:push",
-    "release:minor": "npm run version:all:minor && npm run release:check && npm run release:publish && npm run release:push",
-    "release:major": "npm run version:all:major && npm run release:check && npm run release:publish && npm run release:push"
+    "release:rc:patch": "npm run release:check && npm run version:all:rc:patch && npm run release:push",
+    "release:rc:minor": "npm run release:check && npm run version:all:rc:minor && npm run release:push",
+    "release:rc:major": "npm run release:check && npm run version:all:rc:major && npm run release:push",
+    "release:rc:next": "npm run release:check && npm run version:all:rc:next && npm run release:push",
+    "release:promote": "npm run release:check && npm run version:all:promote && npm run release:publish && npm run release:push",
+    "release:patch": "npm run release:check && npm run version:all:patch && npm run release:publish && npm run release:push",
+    "release:minor": "npm run release:check && npm run version:all:minor && npm run release:publish && npm run release:push",
+    "release:major": "npm run release:check && npm run version:all:major && npm run release:publish && npm run release:push"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.4.8",
     "concurrently": "^9.2.1",
-    "prettier": "^3.5.3",
     "get-port-cli": "^3.0.0",
     "knip": "^5.82.1",
     "patch-package": "^8.0.1",
+    "react": "19.1.4",
+    "react-dom": "19.1.4",
     "typescript": "^5.9.3"
   },
   "description": "Paseo: voice-controlled development environment with OpenAI Realtime API",
+  "homepage": "https://paseo.sh",
   "keywords": [
     "openai",
     "realtime",
@@ -70,7 +82,14 @@
     "development",
     "mcp"
   ],
-  "author": "moboudra",
+  "author": {
+    "name": "Mohamed Boudra",
+    "email": "hello@moboudra.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/getpaseo/paseo.git"
+  },
   "license": "AGPL-3.0-or-later",
   "overrides": {
     "lightningcss": "1.30.1",
@@ -78,6 +97,7 @@
     "react-dom": "19.1.4"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.11"
+    "@anthropic-ai/claude-agent-sdk": "^0.2.11",
+    "@modelcontextprotocol/sdk": "^1.27.1"
   }
 }

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

@@ -4,6 +4,7 @@ on:
   push:
     tags:
       - "v*"
+      - "!v*-rc.*"
   workflow_dispatch: {}
 
 jobs:

packages/app/app.config.js

@@ -65,8 +65,7 @@ export default {
     ios: {
       supportsTablet: true,
       infoPlist: {
-        NSMicrophoneUsageDescription:
-          "This app needs access to the microphone for voice commands.",
+        NSMicrophoneUsageDescription: "This app needs access to the microphone for voice commands.",
         ITSAppUsesNonExemptEncryption: false,
       },
       bundleIdentifier: variant.packageId,
@@ -92,14 +91,15 @@ export default {
         "android.permission.CAMERA",
       ],
       package: variant.packageId,
-      ...(variant.googleServicesFile
-        ? { googleServicesFile: variant.googleServicesFile }
-        : {}),
+      ...(variant.googleServicesFile ? { googleServicesFile: variant.googleServicesFile } : {}),
     },
     web: {
       output: "single",
       favicon: "./assets/images/favicon.png",
     },
+    autolinking: {
+      searchPaths: ["../../node_modules", "./node_modules"],
+    },
     plugins: [
       "expo-router",
       [
@@ -143,6 +143,7 @@ export default {
     experiments: {
       typedRoutes: true,
       reactCompiler: true,
+      autolinkingModuleResolution: true,
     },
     extra: {
       router: {},

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

@@ -1,183 +0,0 @@
-import { test, expect, type Page } from "./fixtures";
-import { createTempGitRepo } from "./helpers/workspace";
-import {
-  connectDaemonClient,
-  createReplyTurn,
-  expectDetachedFromBottom,
-  expectNearBottom,
-  getChatContainerKey,
-  readScrollMetrics,
-  scrollUpFromBottom,
-  seedBottomAnchorAgent,
-  waitForAgentReady,
-  waitForContentGrowth,
-} from "./helpers/agent-bottom-anchor";
-
-test.describe.configure({ timeout: 180000 });
-
-async function openWorkspaceAgentTab(page: Page, agentId: string) {
-  const tab = page.getByTestId(`workspace-tab-agent_${agentId}`).first();
-  await expect(tab).toBeVisible({ timeout: 30000 });
-  await tab.click();
-}
-
-test("direct load and refresh land at the bottom for history-backed chats", async ({
-  page,
-}) => {
-  const repo = await createTempGitRepo("paseo-e2e-bottom-anchor-direct-");
-  const client = await connectDaemonClient();
-
-  try {
-    const agent = await seedBottomAnchorAgent({
-      client,
-      cwd: repo.path,
-      title: `bottom-anchor-direct-${Date.now()}`,
-      turnCount: 4,
-    });
-
-    await page.goto(agent.url, { waitUntil: "domcontentloaded" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expectNearBottom(page);
-
-    await page.reload({ waitUntil: "commit" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expectNearBottom(page);
-  } finally {
-    await client.close().catch(() => undefined);
-    await repo.cleanup();
-  }
-});
-
-test("revisiting a loaded chat restores bottom anchoring", async ({
-  page,
-}) => {
-  const repo = await createTempGitRepo("paseo-e2e-bottom-anchor-switch-");
-  const client = await connectDaemonClient();
-
-  try {
-    const agent = await seedBottomAnchorAgent({
-      client,
-      cwd: repo.path,
-      title: `bottom-anchor-switch-${Date.now()}`,
-      turnCount: 4,
-    });
-
-    await page.goto(agent.url, { waitUntil: "domcontentloaded" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expectNearBottom(page);
-
-    await page.getByTestId("sidebar-new-agent").first().click();
-    await expect(page.getByRole("textbox", { name: "Message agent..." }).first()).toBeVisible({
-      timeout: 30000,
-    });
-
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expectNearBottom(page);
-  } finally {
-    await client.close().catch(() => undefined);
-    await repo.cleanup();
-  }
-});
-
-test("sticky mode stays pinned through composer growth and viewport resize, but detached mode does not fight streamed updates", async ({
-  page,
-}) => {
-  const repo = await createTempGitRepo("paseo-e2e-bottom-anchor-sticky-");
-  const client = await connectDaemonClient();
-
-  try {
-    const agent = await seedBottomAnchorAgent({
-      client,
-      cwd: repo.path,
-      title: `bottom-anchor-sticky-${Date.now()}`,
-      turnCount: 10,
-    });
-
-    await page.setViewportSize({ width: 1320, height: 920 });
-    await page.goto(agent.url, { waitUntil: "domcontentloaded" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expectNearBottom(page);
-
-    const composer = page.getByRole("textbox", { name: "Message agent..." }).first();
-    await composer.click();
-    for (let index = 0; index < 6; index += 1) {
-      await composer.pressSequentially(`composer growth line ${index + 1}`);
-      if (index < 5) {
-        await page.keyboard.press("Shift+Enter");
-      }
-    }
-    await expectNearBottom(page);
-    await expect(page.getByTestId("scroll-to-bottom-button")).toHaveCount(0);
-
-    await page.setViewportSize({ width: 820, height: 760 });
-    await expectNearBottom(page);
-
-    await scrollUpFromBottom(page, 720);
-    await expectDetachedFromBottom(page);
-    const beforeExternalUpdate = await readScrollMetrics(page);
-
-    const externalTurn = createReplyTurn(`external-stream-${Date.now()}`);
-    await client.sendAgentMessage(agent.id, externalTurn.message);
-    await waitForContentGrowth(page, beforeExternalUpdate.contentHeight);
-    const finish = await client.waitForFinish(agent.id, 120000);
-    expect(finish.status).toBe("idle");
-    await expectDetachedFromBottom(page);
-  } finally {
-    await client.close().catch(() => undefined);
-    await repo.cleanup();
-  }
-});
-
-test("web partial virtualization keeps bottom anchoring stable across direct load, refresh, and resize", async ({
-  page,
-}) => {
-  await page.addInitScript(() => {
-    (window as typeof window & {
-      __PASEO_E2E_WEB_PARTIAL_VIRTUALIZATION_THRESHOLD?: number;
-      __PASEO_E2E_WEB_MOUNTED_RECENT_STREAM_ITEMS?: number;
-    }).__PASEO_E2E_WEB_PARTIAL_VIRTUALIZATION_THRESHOLD = 6;
-    (window as typeof window & {
-      __PASEO_E2E_WEB_PARTIAL_VIRTUALIZATION_THRESHOLD?: number;
-      __PASEO_E2E_WEB_MOUNTED_RECENT_STREAM_ITEMS?: number;
-    }).__PASEO_E2E_WEB_MOUNTED_RECENT_STREAM_ITEMS = 4;
-  });
-
-  const repo = await createTempGitRepo("paseo-e2e-bottom-anchor-virtualized-");
-  const client = await connectDaemonClient();
-
-  try {
-    const agent = await seedBottomAnchorAgent({
-      client,
-      cwd: repo.path,
-      title: `bottom-anchor-virtualized-${Date.now()}`,
-      turnCount: 4,
-    });
-
-    await page.goto(agent.url, { waitUntil: "domcontentloaded" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expect
-      .poll(async () => await getChatContainerKey(page))
-      .toBe("web-partial-virtualized");
-    await expectNearBottom(page);
-
-    await page.reload({ waitUntil: "commit" });
-    await openWorkspaceAgentTab(page, agent.id);
-    await waitForAgentReady(page, agent.expectedTailText);
-    await expect
-      .poll(async () => await getChatContainerKey(page))
-      .toBe("web-partial-virtualized");
-    await expectNearBottom(page);
-
-    await page.setViewportSize({ width: 780, height: 720 });
-    await expectNearBottom(page);
-  } finally {
-    await client.close().catch(() => undefined);
-    await repo.cleanup();
-  }
-});

packages/app/e2e/agent-details-sheet.spec.ts

@@ -1,35 +0,0 @@
-import { test, expect } from "./fixtures";
-import { createAgent, ensureHostSelected, gotoHome, setWorkingDirectory } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-
-test("agent details sheet shows IDs and copy toast", async ({ page }) => {
-  test.setTimeout(120_000);
-  const repo = await createTempGitRepo();
-  const prompt = "Respond with exactly: Hello";
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-    await createAgent(page, prompt);
-
-    await page.getByTestId("agent-overflow-menu").click();
-    await expect(page.getByTestId("agent-details-sheet")).toBeVisible();
-
-    await expect(page.getByTestId("agent-details-agent-id")).toBeVisible();
-    await expect(page.getByTestId("agent-details-agent-id-value")).not.toHaveText(
-      "Not available"
-    );
-
-    await expect(page.getByTestId("agent-details-persistence-session-id")).toBeVisible();
-    await expect(
-      page.getByTestId("agent-details-persistence-session-id-value")
-    ).not.toHaveText("Not available", { timeout: 90_000 });
-
-    await page.getByTestId("agent-details-agent-id").click();
-    await expect(page.getByTestId("app-toast")).toBeVisible();
-    await expect(page.getByTestId("app-toast-message")).toHaveText(/copied/i);
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/agent-scroll-submit-firefox.spec.ts

@@ -1,197 +0,0 @@
-import { expect, test, type Page } from "@playwright/test";
-
-const SERVER_ID =
-  process.env.PLAYWRIGHT_REPRO_SERVER_ID ?? "srv_ETXtcjYRGrCI";
-const AGENT_ID =
-  process.env.PLAYWRIGHT_REPRO_AGENT_ID ??
-  "3533e6c3-c0b3-4310-b85c-eb07cbb501a0";
-const APP_BASE_URL = process.env.PLAYWRIGHT_REPRO_BASE_URL ?? "http://localhost:8081";
-const DAEMON_ENDPOINT =
-  process.env.PLAYWRIGHT_REPRO_DAEMON_ENDPOINT ?? "127.0.0.1:6767";
-const SUBMIT_TEXT = process.env.PLAYWRIGHT_REPRO_MESSAGE ?? "hello";
-const AGENT_URL = `${APP_BASE_URL}/h/${SERVER_ID}/agent/${AGENT_ID}`;
-const NEAR_BOTTOM_THRESHOLD_PX = 64;
-
-type ScrollMetrics = {
-  offsetY: number;
-  contentHeight: number;
-  viewportHeight: number;
-  distanceFromBottom: number;
-};
-
-test.use({ browserName: "firefox" });
-
-function seedDaemonRegistryScript(params: {
-  serverId: string;
-  endpoint: string;
-  nowIso: string;
-}) {
-  const daemon = {
-    serverId: params.serverId,
-    label: "localhost",
-    connections: [
-      {
-        id: `direct:${params.endpoint}`,
-        type: "direct",
-        endpoint: params.endpoint,
-      },
-    ],
-    preferredConnectionId: `direct:${params.endpoint}`,
-    createdAt: params.nowIso,
-    updatedAt: params.nowIso,
-  };
-
-  localStorage.setItem("@paseo:e2e", "1");
-  localStorage.setItem("@paseo:daemon-registry", JSON.stringify([daemon]));
-  localStorage.setItem(
-    "@paseo:create-agent-preferences",
-    JSON.stringify({
-      serverId: params.serverId,
-      provider: "codex",
-      providerPreferences: {
-        claude: { model: "haiku" },
-        codex: { model: "gpt-5.1-codex-mini", thinkingOptionId: "low" },
-      },
-    })
-  );
-}
-
-async function readScrollMetrics(page: Page): Promise<ScrollMetrics> {
-  return page.getByTestId("agent-chat-scroll").evaluate((root: Element) => {
-    const rootElement = root as HTMLElement;
-    const candidates = [rootElement, ...Array.from(rootElement.querySelectorAll("*"))];
-    const scrollElement =
-      candidates.find(
-        (element) =>
-          element instanceof HTMLElement &&
-          element.scrollHeight - element.clientHeight > 1
-      ) ?? rootElement;
-
-    const offsetY = Math.max(0, scrollElement.scrollTop);
-    const contentHeight = Math.max(0, scrollElement.scrollHeight);
-    const viewportHeight = Math.max(0, scrollElement.clientHeight);
-    const distanceFromBottom = Math.max(
-      0,
-      contentHeight - (offsetY + viewportHeight)
-    );
-
-    return {
-      offsetY,
-      contentHeight,
-      viewportHeight,
-      distanceFromBottom,
-    };
-  });
-}
-
-async function scrollUpFromBottom(
-  page: Page,
-  pixels: number
-): Promise<void> {
-  await page.getByTestId("agent-chat-scroll").evaluate(
-    (root: Element, amount: number) => {
-      const rootElement = root as HTMLElement;
-      const candidates = [
-        rootElement,
-        ...Array.from(rootElement.querySelectorAll("*")),
-      ];
-      const scrollElement =
-        candidates.find(
-          (element) =>
-            element instanceof HTMLElement &&
-            element.scrollHeight - element.clientHeight > 1
-        ) ?? rootElement;
-
-      const bottomOffset = Math.max(
-        0,
-        scrollElement.scrollHeight - scrollElement.clientHeight
-      );
-      scrollElement.scrollTop = Math.max(0, bottomOffset - amount);
-    },
-    pixels
-  );
-}
-
-test("repro: submit while scrolled up should stay anchored to bottom (Firefox)", async ({
-  page,
-}, testInfo) => {
-  const userAgent = await page.evaluate(() => navigator.userAgent);
-  expect(userAgent).toContain("Firefox");
-
-  await page.addInitScript(seedDaemonRegistryScript, {
-    serverId: SERVER_ID,
-    endpoint: DAEMON_ENDPOINT,
-    nowIso: new Date().toISOString(),
-  });
-
-  await page.goto(AGENT_URL, { waitUntil: "domcontentloaded" });
-  await expect(page.getByTestId("agent-chat-scroll")).toBeVisible({
-    timeout: 60_000,
-  });
-  await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeVisible({
-    timeout: 60_000,
-  });
-
-  // Require enough history so the repro actually scrolls away from bottom.
-  await expect
-    .poll(async () => {
-      const metrics = await readScrollMetrics(page);
-      return Math.max(0, metrics.contentHeight - metrics.viewportHeight);
-    })
-    .toBeGreaterThan(300);
-
-  await scrollUpFromBottom(page, 900);
-  await page.waitForTimeout(250);
-  const beforeSubmit = await readScrollMetrics(page);
-  const beforePath = testInfo.outputPath("before-submit.png");
-  await page.screenshot({ path: beforePath, fullPage: true });
-  await testInfo.attach("before-submit", {
-    path: beforePath,
-    contentType: "image/png",
-  });
-
-  await page.getByRole("textbox", { name: "Message agent..." }).fill(SUBMIT_TEXT);
-  await page.getByRole("textbox", { name: "Message agent..." }).press("Enter");
-  await page.waitForTimeout(1200);
-
-  const afterSubmit = await readScrollMetrics(page);
-  const afterPath = testInfo.outputPath("after-submit.png");
-  await page.screenshot({ path: afterPath, fullPage: true });
-  await testInfo.attach("after-submit", {
-    path: afterPath,
-    contentType: "image/png",
-  });
-  await testInfo.attach("firefox-scroll-metrics", {
-    body: JSON.stringify(
-      {
-        url: AGENT_URL,
-        submitText: SUBMIT_TEXT,
-        thresholdPx: NEAR_BOTTOM_THRESHOLD_PX,
-        beforeScreenshot: beforePath,
-        afterScreenshot: afterPath,
-        beforeSubmit,
-        afterSubmit,
-      },
-      null,
-      2
-    ),
-    contentType: "application/json",
-  });
-
-  console.log(
-    `[firefox-scroll-repro] ${JSON.stringify(
-      {
-        submitText: SUBMIT_TEXT,
-        beforeSubmit,
-        afterSubmit,
-      },
-      null,
-      2
-    )}`
-  );
-
-  expect(beforeSubmit.distanceFromBottom).toBeGreaterThan(NEAR_BOTTOM_THRESHOLD_PX);
-  expect(afterSubmit.distanceFromBottom).toBeLessThanOrEqual(
-    NEAR_BOTTOM_THRESHOLD_PX
-  );
-});

packages/app/e2e/agent-timeline-hydration.spec.ts

@@ -1,27 +0,0 @@
-import { test, expect } from './fixtures';
-import { createAgent, ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test('agent timeline hydrates after reload via fetch_agent_timeline_request', async ({ page }) => {
-  const repo = await createTempGitRepo();
-  const prompt = 'Respond with exactly: TIMELINE_HYDRATION_OK';
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-    await createAgent(page, prompt);
-    await expect(page.getByText(prompt, { exact: true }).first()).toBeVisible({
-      timeout: 30000,
-    });
-
-    await page.reload({ waitUntil: 'commit' });
-    await expect(page).toHaveURL(/\/agent\//);
-    await expect(page.getByTestId('agent-loading')).toHaveCount(0, { timeout: 30000 });
-    await expect(page.getByText(prompt, { exact: true }).first()).toBeVisible({
-      timeout: 30000,
-    });
-  } finally {
-    await repo.cleanup();
-  }
-});

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

@@ -0,0 +1,108 @@
+import { randomUUID } from "node:crypto";
+import { test } from "./fixtures";
+import { createTempGitRepo } from "./helpers/workspace";
+import {
+  archiveAgentFromDaemon,
+  archiveAgentFromSessions,
+  connectArchiveTabDaemonClient,
+  createIdleAgent,
+  expectSessionRowVisible,
+  expectWorkspaceArchiveOutcome,
+  openSessions,
+  openWorkspaceWithAgents,
+  primeAdditionalPage,
+  resetSeededPageState,
+  reloadWorkspace,
+} from "./helpers/archive-tab";
+
+test.describe("Archive tab reconciliation", () => {
+  let client: Awaited<ReturnType<typeof connectArchiveTabDaemonClient>>;
+  let tempRepo: { path: string; cleanup: () => Promise<void> };
+
+  test.describe.configure({ timeout: 120_000 });
+
+  test.beforeAll(async () => {
+    tempRepo = await createTempGitRepo("archive-tab-");
+    client = await connectArchiveTabDaemonClient();
+  });
+
+  test.afterAll(async () => {
+    await client?.close().catch(() => undefined);
+    await tempRepo?.cleanup();
+  });
+
+  test("non-UI archive prunes the archived tab across open pages and reload", async ({ page }) => {
+    const archived = await createIdleAgent(client, {
+      cwd: tempRepo.path,
+      title: `cli-archive-${randomUUID().slice(0, 8)}`,
+    });
+    const surviving = await createIdleAgent(client, {
+      cwd: tempRepo.path,
+      title: `cli-control-${randomUUID().slice(0, 8)}`,
+    });
+    const passivePage = await page.context().newPage();
+
+    try {
+      await primeAdditionalPage(passivePage);
+      await resetSeededPageState(page);
+      await resetSeededPageState(passivePage);
+      await openSessions(page);
+      await expectSessionRowVisible(page, archived.title);
+      await expectSessionRowVisible(page, surviving.title);
+      await openSessions(passivePage);
+      await expectSessionRowVisible(passivePage, archived.title);
+      await expectSessionRowVisible(passivePage, surviving.title);
+      await openWorkspaceWithAgents(page, [archived, surviving]);
+      await openWorkspaceWithAgents(passivePage, [archived, surviving]);
+      await archiveAgentFromDaemon(client, archived.id);
+      await expectWorkspaceArchiveOutcome(page, {
+        archivedAgentId: archived.id,
+        survivingAgentId: surviving.id,
+      });
+      await expectWorkspaceArchiveOutcome(passivePage, {
+        archivedAgentId: archived.id,
+        survivingAgentId: surviving.id,
+      });
+      await reloadWorkspace(passivePage, tempRepo.path);
+      await expectWorkspaceArchiveOutcome(passivePage, {
+        archivedAgentId: archived.id,
+        survivingAgentId: surviving.id,
+      });
+    } finally {
+      await passivePage.close();
+    }
+  });
+
+  test("Sessions archive prunes the archived tab across open pages", async ({ page }) => {
+    const archived = await createIdleAgent(client, {
+      cwd: tempRepo.path,
+      title: `ui-archive-${randomUUID().slice(0, 8)}`,
+    });
+    const surviving = await createIdleAgent(client, {
+      cwd: tempRepo.path,
+      title: `ui-control-${randomUUID().slice(0, 8)}`,
+    });
+    const passivePage = await page.context().newPage();
+
+    try {
+      await primeAdditionalPage(passivePage);
+      await resetSeededPageState(page);
+      await resetSeededPageState(passivePage);
+      await openWorkspaceWithAgents(page, [archived, surviving]);
+      await openWorkspaceWithAgents(passivePage, [archived, surviving]);
+      await openSessions(page);
+      await archiveAgentFromSessions(page, { agentId: archived.id, title: archived.title });
+      await reloadWorkspace(page, tempRepo.path);
+      await expectWorkspaceArchiveOutcome(page, {
+        archivedAgentId: archived.id,
+        survivingAgentId: surviving.id,
+      });
+      await expectWorkspaceArchiveOutcome(passivePage, {
+        archivedAgentId: archived.id,
+        survivingAgentId: surviving.id,
+      });
+    } finally {
+      await passivePage.close();
+    }
+  });
+});

packages/app/e2e/checkout-ship.spec.ts

@@ -1,440 +0,0 @@
-import path from 'node:path';
-import { appendFile, mkdtemp, rm, writeFile, realpath } from 'node:fs/promises';
-import { execSync } from 'node:child_process';
-import { tmpdir } from 'node:os';
-import { test, expect, type Page } from './fixtures';
-import {
-  createAgent,
-  ensureHostSelected,
-  gotoHome,
-  setWorkingDirectory,
-} from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test.describe.configure({ mode: 'serial', timeout: 120000 });
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function getChangesScope(page: Page) {
-  return page.locator('[data-testid="explorer-content-area"]:visible').first();
-}
-
-function getChangesHeader(page: Page) {
-  return getChangesScope(page).getByTestId('changes-header');
-}
-
-async function ensureExplorerTabsVisible(page: Page) {
-  const changesTab = page.getByTestId('explorer-tab-changes').first();
-  if (await changesTab.isVisible().catch(() => false)) {
-    return;
-  }
-
-  const toggle = page
-    .getByRole('button', { name: /open explorer|close explorer|toggle explorer/i })
-    .first();
-  await expect(toggle).toBeVisible({ timeout: 10000 });
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    if (await changesTab.isVisible().catch(() => false)) {
-      return;
-    }
-    await toggle.click();
-    await page.waitForTimeout(200);
-  }
-  await expect(changesTab).toBeVisible({ timeout: 30000 });
-}
-
-async function selectChangesView(page: Page, view: 'working' | 'base') {
-  // Defensive: close any open dropdown menus (their backdrops intercept clicks).
-  const primaryBackdrop = page.getByTestId('changes-primary-cta-menu-backdrop');
-  if (await primaryBackdrop.isVisible().catch(() => false)) {
-    await primaryBackdrop.click({ force: true });
-    await expect(primaryBackdrop).toHaveCount(0);
-  }
-  const overflowBackdrop = page.getByTestId('changes-overflow-content-backdrop');
-  if (await overflowBackdrop.isVisible().catch(() => false)) {
-    await overflowBackdrop.click({ force: true });
-    await expect(overflowBackdrop).toHaveCount(0);
-  }
-  const diffModeBackdrop = page.getByTestId('changes-diff-status-menu-backdrop');
-  if (await diffModeBackdrop.isVisible().catch(() => false)) {
-    await diffModeBackdrop.click({ force: true });
-    await expect(diffModeBackdrop).toHaveCount(0);
-  }
-
-  const scope = getChangesScope(page);
-  const modeToggle = scope.getByTestId('changes-diff-status').first();
-  const expected = view === 'working' ? 'Uncommitted' : 'Committed';
-  if (!(await modeToggle.isVisible().catch(() => false))) {
-    return;
-  }
-  const current = ((await modeToggle.innerText().catch(() => '')) ?? '').trim();
-  if (current !== expected) {
-    await modeToggle.click();
-    const menu = page.getByTestId('changes-diff-status-menu');
-    await expect(menu).toBeVisible({ timeout: 10000 });
-    const optionTestId =
-      view === 'working' ? 'changes-diff-mode-uncommitted' : 'changes-diff-mode-committed';
-    await page.getByTestId(optionTestId).click({ force: true });
-  }
-  await expect(modeToggle).toContainText(expected, { timeout: 10000 });
-}
-
-async function openChangesPrimaryMenu(page: Page) {
-  const scope = getChangesScope(page);
-  const caret = scope.getByTestId('changes-primary-cta-caret').first();
-  await expect(caret).toBeVisible();
-  await caret.click();
-  // Menu content is rendered via a portal, so don't scope it to the explorer content area.
-  await expect(page.getByTestId('changes-primary-cta-menu')).toBeVisible();
-}
-
-async function openChangesPanel(page: Page, options?: { expectGit?: boolean }) {
-  await ensureExplorerTabsVisible(page);
-  const changesHeader = getChangesHeader(page);
-  if (!(await changesHeader.isVisible())) {
-    await page.getByTestId('explorer-tab-changes').first().click();
-  }
-  await expect(changesHeader).toBeVisible({ timeout: 30000 });
-  if (options?.expectGit === false) {
-    return;
-  }
-  const changesScope = getChangesScope(page);
-  await expect(changesScope.getByTestId('changes-not-git')).toHaveCount(0, {
-    timeout: 30000,
-  });
-  await expect(changesScope.getByTestId('changes-branch')).not.toHaveText('Not a git repository', {
-    timeout: 30000,
-  });
-}
-
-async function waitForAgentTurnToSettle(page: Page, timeout = 90000) {
-  const stopButton = page.getByRole('button', { name: /stop agent|stop/i }).first();
-  if (!(await stopButton.isVisible().catch(() => false))) {
-    return;
-  }
-  await expect(stopButton).not.toBeVisible({ timeout });
-}
-
-async function createAgentAndWait(page: Page, message: string) {
-  await createAgent(page, message);
-}
-
-async function selectAttachWorktree(page: Page, branchName: string) {
-  const trigger = page.getByTestId('worktree-select-trigger').first();
-  await expect(trigger).toBeVisible({ timeout: 30000 });
-  await trigger.click();
-
-  const menu = page.getByTestId('combobox-desktop-container').first();
-  await expect(menu).toBeVisible({ timeout: 10000 });
-  const searchInput = page.getByRole('textbox', { name: /search worktrees/i }).first();
-  if (await searchInput.isVisible().catch(() => false)) {
-    await searchInput.fill(branchName);
-  }
-
-  const preferredOption = menu
-    .getByText(new RegExp(`^${escapeRegex(branchName)}$`, 'i'))
-    .first();
-  await expect(preferredOption).toBeVisible({ timeout: 10000 });
-  await preferredOption.click({ force: true });
-  await expect(menu).toHaveCount(0);
-  await expect(trigger).toContainText(branchName, { timeout: 30000 });
-}
-
-async function enableCreateWorktree(page: Page) {
-  const trigger = page.getByTestId('worktree-select-trigger').first();
-  await expect(trigger).toBeVisible({ timeout: 30000 });
-
-  const currentValue = ((await trigger.innerText().catch(() => '')) ?? '').trim();
-  if (/Create new worktree/i.test(currentValue)) {
-    await expect(page.getByTestId('worktree-base-branch-trigger')).toBeVisible({
-      timeout: 30000,
-    });
-    return;
-  }
-
-  await trigger.click();
-  const menu = page.getByTestId('combobox-desktop-container').first();
-  await expect(menu).toBeVisible({ timeout: 10000 });
-  const createOption = menu.getByText('Create new worktree', { exact: true }).first();
-  await expect(createOption).toBeVisible({ timeout: 10000 });
-  await createOption.click({ force: true });
-  await expect(menu).toHaveCount(0);
-  await expect(trigger).toContainText('Create new worktree', { timeout: 30000 });
-  await expect(page.getByTestId('worktree-base-branch-trigger')).toBeVisible({
-    timeout: 30000,
-  });
-}
-
-async function refreshUncommittedMode(page: Page) {
-  await selectChangesView(page, 'base');
-  await selectChangesView(page, 'working');
-}
-
-async function refreshChangesTab(page: Page) {
-  await ensureExplorerTabsVisible(page);
-  await page.getByTestId('explorer-tab-files').first().click();
-  await page.getByTestId('explorer-tab-changes').first().click();
-}
-
-function normalizeTmpPath(value: string) {
-  if (value.startsWith('/var/')) {
-    return `/private${value}`;
-  }
-  return value;
-}
-
-type GitWorktreeEntry = {
-  worktreePath: string;
-  branchRef: string | null;
-};
-
-function parseGitWorktreeList(raw: string): GitWorktreeEntry[] {
-  const blocks = raw
-    .split(/\n\s*\n/g)
-    .map((block) => block.trim())
-    .filter((block) => block.length > 0);
-
-  const entries: GitWorktreeEntry[] = [];
-  for (const block of blocks) {
-    const worktreeMatch = block.match(/^worktree (.+)$/m);
-    if (!worktreeMatch) {
-      continue;
-    }
-    const branchMatch = block.match(/^branch (.+)$/m);
-    entries.push({
-      worktreePath: worktreeMatch[1].trim(),
-      branchRef: branchMatch ? branchMatch[1].trim() : null,
-    });
-  }
-  return entries;
-}
-
-async function waitForCreatedWorktree(repoPath: string, timeoutMs = 30000) {
-  const deadline = Date.now() + timeoutMs;
-  const normalizedRepoPath = normalizeTmpPath(repoPath);
-
-  while (Date.now() < deadline) {
-    try {
-      const output = execSync('git worktree list --porcelain', {
-        cwd: repoPath,
-        encoding: 'utf8',
-      });
-      const entries = parseGitWorktreeList(output);
-      const candidate = entries.find((entry) => {
-        const normalizedWorktreePath = normalizeTmpPath(entry.worktreePath);
-        if (normalizedWorktreePath === normalizedRepoPath) {
-          return false;
-        }
-        if (!entry.branchRef) {
-          return false;
-        }
-        return !/\/main$/i.test(entry.branchRef);
-      });
-
-      if (candidate) {
-        const branchName = candidate.branchRef?.split('/').filter(Boolean).pop();
-        if (branchName) {
-          return {
-            worktreePath: candidate.worktreePath,
-            branchName,
-          };
-        }
-      }
-    } catch {
-      // Ignore transient git worktree read errors while polling.
-    }
-    await new Promise((resolve) => setTimeout(resolve, 250));
-  }
-
-  throw new Error(`Timed out waiting for a non-main worktree under ${repoPath}`);
-}
-
-test('checkout-first Changes panel ship loop', async ({ page }) => {
-  const repo = await createTempGitRepo('paseo-e2e-', { withRemote: true });
-  const nonGitDir = await mkdtemp(path.join(tmpdir(), 'paseo-e2e-non-git-'));
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-
-    await enableCreateWorktree(page);
-    await createAgentAndWait(page, 'Respond with exactly: READY');
-    await waitForAgentTurnToSettle(page);
-
-    await openChangesPanel(page);
-    const branchLabelLocator = getChangesScope(page).getByTestId('changes-branch');
-    await expect
-      .poll(async () => (await branchLabelLocator.innerText()).trim(), { timeout: 30000 })
-      .not.toBe('Unknown');
-    const branchNameFromUi = (await branchLabelLocator.innerText()).trim();
-    expect(branchNameFromUi.length).toBeGreaterThan(0);
-
-    const { worktreePath: firstCwd, branchName: worktreeBranch } = await waitForCreatedWorktree(
-      repo.path
-    );
-    expect(worktreeBranch.length).toBeGreaterThan(0);
-    const [resolvedCwd, resolvedRepo] = await Promise.all([
-      realpath(firstCwd).catch(() => firstCwd),
-      realpath(repo.path).catch(() => repo.path),
-    ]);
-    const normalizedRepo = normalizeTmpPath(resolvedRepo);
-    const normalizedCwd = normalizeTmpPath(resolvedCwd);
-    const expectedMarker = `${path.sep}worktrees${path.sep}`;
-    expect(normalizedCwd.includes(expectedMarker)).toBeTruthy();
-
-    await page.getByTestId('sidebar-new-agent').click();
-    await expect(page).toHaveURL(/\/h\/[^/]+\/agent(\?|$)/);
-
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-    await selectAttachWorktree(page, worktreeBranch);
-    await createAgentAndWait(page, 'Respond with exactly: READY2');
-    await waitForAgentTurnToSettle(page);
-    await openChangesPanel(page);
-
-    const readmePath = path.join(firstCwd, 'README.md');
-    await appendFile(readmePath, '\nFirst change\n');
-
-    await refreshUncommittedMode(page);
-    await expect(getChangesScope(page).getByText('README.md', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-    await getChangesScope(page).getByTestId('diff-file-0-toggle').first().click();
-    await expect(page.getByText('First change')).toBeVisible();
-    const primaryCta = getChangesScope(page).getByTestId('changes-primary-cta').first();
-    await expect(primaryCta).toBeVisible();
-    await expect(primaryCta).toContainText('Commit');
-
-    await primaryCta.click();
-    await expect
-      .poll(() => {
-        try {
-          return execSync('git status --porcelain', {
-            cwd: firstCwd,
-            encoding: 'utf8',
-            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-          }).trim();
-        } catch {
-          return null;
-        }
-      }, { timeout: 30000 })
-      .toBe('');
-    await openChangesPanel(page);
-    await selectChangesView(page, 'working');
-    await expect(getChangesScope(page).getByText('No uncommitted changes')).toBeVisible({
-      timeout: 30000,
-    });
-    await expect(getChangesScope(page).getByTestId('changes-primary-cta')).not.toContainText('Commit');
-
-    await selectChangesView(page, 'base');
-    await expect(getChangesScope(page).getByText('README.md', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-
-    // Push once from the menu so the branch has an origin/<branch> ref.
-    await openChangesPrimaryMenu(page);
-    await page.getByTestId('changes-menu-push').click();
-    await expect
-      .poll(() => {
-        try {
-          execSync(`git show-ref --verify --quiet refs/remotes/origin/${worktreeBranch}`, { cwd: firstCwd });
-          return true;
-        } catch {
-          return false;
-        }
-      }, { timeout: 30000 })
-      .toBe(true);
-
-    const notesPath = path.join(firstCwd, 'notes.txt');
-    await writeFile(notesPath, 'Second change\n');
-
-    await refreshUncommittedMode(page);
-    await refreshChangesTab(page);
-    await expect(getChangesScope(page).getByText('notes.txt', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-    await expect(getChangesScope(page).getByText('README.md', { exact: true })).toHaveCount(0);
-    await expect(getChangesScope(page).getByTestId('changes-primary-cta')).toContainText('Commit');
-
-    await selectChangesView(page, 'base');
-    await expect(getChangesScope(page).getByText('README.md', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-
-    await getChangesScope(page).getByTestId('changes-primary-cta').click();
-    await expect
-      .poll(() => {
-        try {
-          return execSync('git status --porcelain', {
-            cwd: firstCwd,
-            encoding: 'utf8',
-            env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
-          }).trim();
-        } catch {
-          return null;
-        }
-      }, { timeout: 30000 })
-      .toBe('');
-    await openChangesPanel(page);
-    await selectChangesView(page, 'working');
-    await expect(getChangesScope(page).getByText('No uncommitted changes')).toBeVisible({ timeout: 30000 });
-    await expect(getChangesScope(page).getByTestId('changes-primary-cta')).not.toContainText('Commit');
-
-    await selectChangesView(page, 'base');
-    await expect(getChangesScope(page).getByText('README.md', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-    await expect(getChangesScope(page).getByText('notes.txt', { exact: true })).toBeVisible({
-      timeout: 30000,
-    });
-
-    // Push is now the primary action (origin/<branch> exists and we're ahead of it).
-    const pushPrimary = getChangesScope(page).getByTestId('changes-primary-cta').first();
-    await expect(pushPrimary).toContainText(/push/i, { timeout: 30000 });
-    await pushPrimary.click();
-    // Regression check: the primary CTA stays in place while pushing.
-    await expect(pushPrimary).toBeVisible();
-    await page.waitForTimeout(50);
-    await expect(pushPrimary).toBeVisible();
-
-    await expect
-      .poll(() => {
-        try {
-          const count = execSync(
-            `git rev-list --count origin/${worktreeBranch}..${worktreeBranch}`,
-            { cwd: firstCwd, encoding: 'utf8' }
-          ).trim();
-          return Number.parseInt(count, 10);
-        } catch {
-          return null;
-        }
-      }, { timeout: 30000 })
-      .toBe(0);
-
-    // Merge to base in the main worktree (worktree branches can't always check out base refs in-place).
-    // This avoids UI flakiness around ship actions while still validating the diff panel end-to-end.
-    execSync("git checkout main", { cwd: repo.path });
-    execSync(`git -c commit.gpgsign=false merge --no-edit ${worktreeBranch}`, { cwd: repo.path });
-    execSync("git push", { cwd: repo.path });
-
-    await selectChangesView(page, 'base');
-    await expect(getChangesScope(page).getByTestId('changes-diff-status')).toContainText(
-      'Committed',
-      { timeout: 30000 }
-    );
-    await refreshChangesTab(page);
-
-    // Post-ship UI behavior is implementation-dependent (archive can be promoted into
-    // primary flow or hidden behind menu variants), so continue from a fresh draft.
-    await page.getByTestId('sidebar-new-agent').click();
-    await expect(page).toHaveURL(/\/h\/[^/]+\/agent(?:\?|$)/, { timeout: 30000 });
-
-    await expect(page.getByRole('textbox', { name: 'Message agent...' })).toBeEditable();
-  } finally {
-    await rm(nonGitDir, { recursive: true, force: true });
-    await repo.cleanup();
-  }
-});

packages/app/e2e/create-agent.spec.ts

@@ -1,27 +0,0 @@
-import { test, expect } from './fixtures';
-import { createAgentInRepo } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test('create agent in a temp repo', async ({ page }) => {
-  const repo = await createTempGitRepo();
-  const prompt = "Respond with exactly: Hello";
-
-  try {
-    await createAgentInRepo(page, { directory: repo.path, prompt });
-
-    // Verify user message is shown in the stream
-    await expect(page.getByText(prompt, { exact: true })).toBeVisible();
-
-    // Verify we used the seeded fast model (do not fall back to other defaults).
-    const modelPicker = page.getByRole("button", { name: /select agent model/i }).first();
-    await expect(modelPicker).toBeVisible({ timeout: 30000 });
-    await expect(modelPicker).toContainText(/gpt-5\.1-codex-mini/i);
-
-    // Verify the assistant response is rendered.
-    await expect(page.getByText("Hello", { exact: true }).first()).toBeVisible({
-      timeout: 30000,
-    });
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/daemon-connectivity.spec.ts

@@ -1,19 +0,0 @@
-import { test, expect } from './fixtures';
-import { gotoHome, openSettings } from './helpers/app';
-
-test('daemon is connected in settings', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  await gotoHome(page);
-  await openSettings(page);
-
-  await expect(page.getByText(`127.0.0.1:${daemonPort}`)).toBeVisible();
-  await expect(page.getByTestId(`daemon-card-${serverId}`).getByText('Online', { exact: true })).toBeVisible();
-});

packages/app/e2e/delete-agent-persists.spec.ts

@@ -1,64 +0,0 @@
-import { test, expect } from './fixtures';
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test('deleting an agent persists after reload', async ({ page }) => {
-  const repo = await createTempGitRepo();
-  const nonce = Math.random().toString(36).slice(2, 10);
-  const prompt = `respond-ready-${nonce}`;
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-
-    // Create agent (via message input) so it shows up in the sidebar list.
-    const input = page.getByRole('textbox', { name: 'Message agent...' });
-    await expect(input).toBeEditable();
-    await input.fill(prompt);
-    await input.press('Enter');
-    await expect(page).toHaveURL(/\/h\/[^/]+\/agent\/[^/?#]+(?:\?|$)/, {
-      timeout: 30000,
-    });
-    // Wait for the initial turn to complete so the agent can be archived (web uses a hover action).
-    const stopOrCancel = page.getByRole('button', { name: /Stop agent|Canceling agent/ });
-    await stopOrCancel.first().waitFor({ state: 'visible', timeout: 30000 }).catch(() => undefined);
-    await expect(stopOrCancel).toHaveCount(0, { timeout: 120000 });
-
-    const match =
-      page.url().match(/\/h\/([^/]+)\/agent\/([^/?#]+)/) ??
-      page.url().match(/\/agent\/([^/]+)\/([^/?#]+)/);
-    if (!match) {
-      throw new Error(`Expected /h/:serverId/agent/:agentId URL, got ${page.url()}`);
-    }
-    const serverId = decodeURIComponent(match[1]);
-    const agentId = decodeURIComponent(match[2]);
-
-    // Return home and delete via long-press in the agent list.
-    await gotoHome(page);
-    const rowTestId = `agent-row-${serverId}-${agentId}`;
-    const agentRow = page.getByTestId(rowTestId).first();
-    await expect(agentRow).toBeVisible({ timeout: 30000 });
-
-    // Web UX: hover shows a quick-archive icon. First click enters confirm state; second click archives.
-    await agentRow.hover();
-    const quickArchive = page.getByTestId(`agent-archive-${serverId}-${agentId}`).first();
-    await expect(quickArchive).toBeVisible({ timeout: 10000 });
-    await quickArchive.click({ force: true });
-    const confirmArchive = page
-      .getByTestId(`agent-archive-confirm-${serverId}-${agentId}`)
-      .first();
-    await expect(confirmArchive).toBeVisible({ timeout: 10000 });
-    await confirmArchive.click({ force: true });
-
-    // Ensure deletion finished before reload (avoids races).
-    await expect(page.getByTestId(rowTestId)).toHaveCount(0, { timeout: 30000 });
-
-    // A full reload should not bring the agent back.
-    await page.reload();
-    await expect(page.getByRole('textbox', { name: 'Message agent...' })).toBeVisible();
-    await expect(page.getByTestId(rowTestId)).toHaveCount(0, { timeout: 30000 });
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/dictation-web.spec.ts

@@ -1,342 +0,0 @@
-import { test, expect } from './fixtures';
-import {
-  createAgent,
-  createAgentInRepo,
-  ensureHostSelected,
-  gotoHome,
-  openSettings,
-  setWorkingDirectory,
-} from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-import type { Page } from '@playwright/test';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import {
-  buildHostWorkspaceAgentRoute,
-  buildHostWorkspaceRoute,
-} from '@/utils/host-routes';
-import {
-  ensureWorkspaceAgentPaneVisible,
-  waitForWorkspaceTabsVisible,
-} from './helpers/workspace-tabs';
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-async function addFakeMicrophone(page: Page) {
-  const fixturePath = path.resolve(__dirname, 'fixtures', 'recording.wav');
-  const base64Audio = (await readFile(fixturePath)).toString('base64');
-  const mimeType = 'audio/wav';
-
-  return page.addInitScript(({ base64Audio, mimeType }) => {
-    const mic = {
-      active: 0,
-      getUserMediaCalls: 0,
-      stopCalls: 0,
-      lastRecorder: null as null | { state: string },
-    };
-    (window as any).__mic = mic;
-
-    (window as any).isSecureContext = true;
-
-    const nav = navigator as any;
-    if (!nav.mediaDevices) {
-      nav.mediaDevices = {};
-    }
-    nav.mediaDevices.getUserMedia = async () => {
-      mic.getUserMediaCalls += 1;
-      mic.active += 1;
-      const track = {
-        stop: () => {
-          mic.stopCalls += 1;
-          mic.active = Math.max(0, mic.active - 1);
-        },
-      };
-      return {
-        getTracks: () => [track],
-      };
-    };
-
-    const AudioContextCtor =
-      (window as any).AudioContext ?? (window as any).webkitAudioContext;
-    if (AudioContextCtor?.prototype?.createMediaStreamSource) {
-      const nativeCreateMediaStreamSource =
-        AudioContextCtor.prototype.createMediaStreamSource;
-      AudioContextCtor.prototype.createMediaStreamSource =
-        function patchedCreateMediaStreamSource(stream: unknown) {
-          const isFakeStream =
-            !!stream &&
-            typeof (stream as { getTracks?: unknown }).getTracks === 'function' &&
-            typeof (stream as { id?: unknown }).id === 'undefined';
-          if (isFakeStream) {
-            throw new Error('Force recorder fallback for fake microphone stream');
-          }
-          return nativeCreateMediaStreamSource.call(this, stream);
-        };
-    }
-
-    const blobFromBase64 = (base64: string, mimeType: string): Blob => {
-      const binaryString = atob(base64);
-      const bytes = new Uint8Array(binaryString.length);
-      for (let i = 0; i < binaryString.length; i++) {
-        bytes[i] = binaryString.charCodeAt(i);
-      }
-      return new Blob([bytes], { type: mimeType });
-    };
-
-    class FakeMediaRecorder extends EventTarget {
-      public static isTypeSupported() {
-        return true;
-      }
-
-      public state: 'inactive' | 'recording' = 'inactive';
-      public mimeType: string;
-      public ondataavailable: ((event: { data: Blob }) => void) | null = null;
-      public onerror: ((event: unknown) => void) | null = null;
-
-      constructor(_stream: unknown, options?: MediaRecorderOptions) {
-        super();
-        this.mimeType = options?.mimeType ?? 'audio/webm';
-        mic.lastRecorder = this;
-      }
-
-      public start() {
-        this.state = 'recording';
-      }
-
-      public stop() {
-        if (this.state !== 'recording') {
-          throw new Error('Not recording');
-        }
-        this.state = 'inactive';
-        try {
-          this.ondataavailable?.({
-            data: blobFromBase64(base64Audio, mimeType),
-          });
-        } catch (err) {
-          this.onerror?.(err);
-        }
-        this.dispatchEvent(new Event('stop'));
-      }
-    }
-
-    (window as any).MediaRecorder = FakeMediaRecorder;
-  }, { base64Audio, mimeType });
-}
-
-async function expectComposerReady(page: Page) {
-  await expect(page.getByRole('textbox', { name: 'Message agent...' }).first()).toBeEditable();
-}
-
-async function expectDictationStarted(page: Page) {
-  await expect
-    .poll(async () => page.evaluate(() => (window as any).__mic.active as number))
-    .toBe(1);
-}
-
-async function expectDictationStopped(page: Page) {
-  await expect
-    .poll(async () => page.evaluate(() => (window as any).__mic.active as number))
-    .toBe(0);
-}
-
-test('dictation hotkey works on a workspace agent tab', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    const serverId = process.env.E2E_SERVER_ID;
-    if (!serverId) {
-      throw new Error('E2E_SERVER_ID is not set.');
-    }
-
-    await createAgentInRepo(page, {
-      directory: repo.path,
-      prompt: 'Respond with exactly: Hello',
-    });
-    await page.goto(buildHostWorkspaceRoute(serverId, repo.path));
-    await waitForWorkspaceTabsVisible(page);
-    await ensureWorkspaceAgentPaneVisible(page);
-    await expect(page).toHaveURL(/\/workspace\//);
-    await expectComposerReady(page);
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStarted(page);
-
-    const calls = await page.evaluate(() => (window as any).__mic.getUserMediaCalls as number);
-    expect(calls).toBe(1);
-
-    await page.keyboard.press('Escape');
-    await expectDictationStopped(page);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test('dictation hotkey works on a workspace draft tab', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    const serverId = process.env.E2E_SERVER_ID;
-    if (!serverId) {
-      throw new Error('E2E_SERVER_ID is not set.');
-    }
-
-    await createAgentInRepo(page, {
-      directory: repo.path,
-      prompt: 'Respond with exactly: Hello',
-    });
-    await page.goto(buildHostWorkspaceRoute(serverId, repo.path));
-    await waitForWorkspaceTabsVisible(page);
-    await ensureWorkspaceAgentPaneVisible(page);
-
-    await page.getByTestId('workspace-new-agent-tab').first().click();
-    await expectComposerReady(page);
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStarted(page);
-
-    const calls = await page.evaluate(() => (window as any).__mic.getUserMediaCalls as number);
-    expect(calls).toBe(1);
-
-    await page.keyboard.press('Escape');
-    await expectDictationStopped(page);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test('dictation hotkeys do not trigger on background screens', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    await gotoHome(page);
-    await ensureHostSelected(page);
-    await setWorkingDirectory(page, repo.path);
-    await createAgent(page, 'Respond with exactly: Hello');
-    await expect(page).toHaveURL(/\/workspace\//);
-    await expectComposerReady(page);
-
-    await openSettings(page);
-    await page.keyboard.press('Control+d');
-    await page.waitForTimeout(200);
-
-    const calls = await page.evaluate(() => (window as any).__mic.getUserMediaCalls as number);
-    const active = await page.evaluate(() => (window as any).__mic.active as number);
-
-    expect(calls).toBe(0);
-    expect(active).toBe(0);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test('dictation transcribes fixture via real STT', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    await gotoHome(page);
-    await ensureHostSelected(page);
-    await setWorkingDirectory(page, repo.path);
-    await createAgent(page, 'Respond with exactly: Hello');
-    await expect(page).toHaveURL(/\/workspace\//);
-    await expectComposerReady(page);
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStarted(page);
-
-    const initialCopyMessageCount = await page
-      .getByRole('button', { name: 'Copy message' })
-      .count();
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStopped(page);
-
-    await expect
-      .poll(
-        async () => page.getByRole('button', { name: 'Copy message' }).count(),
-        { timeout: 60_000 }
-      )
-      .toBeGreaterThan(initialCopyMessageCount);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test('cancel stops mic even if recorder is already inactive', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    await gotoHome(page);
-    await ensureHostSelected(page);
-    await setWorkingDirectory(page, repo.path);
-    await createAgent(page, 'Respond with exactly: Hello');
-
-    await expect(page).toHaveURL(/\/workspace\//);
-    await expectComposerReady(page);
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStarted(page);
-
-    await page.evaluate(() => {
-      const mic = (window as any).__mic as { lastRecorder: null | { state: string } };
-      if (mic.lastRecorder) {
-        mic.lastRecorder.state = 'inactive';
-      }
-    });
-
-    await page.keyboard.press('Escape');
-    await expectDictationStopped(page);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test('dictation confirm+send does not dispatch after navigating away', async ({ page }) => {
-  await addFakeMicrophone(page);
-
-  const repo = await createTempGitRepo();
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-    await createAgent(page, 'Respond with exactly: Hello');
-
-    await expect(page).toHaveURL(/\/workspace\//);
-    const match = page.url().match(/\/h\/([^/]+)\/workspace\/[^?]+(?:\?open=agent%3A|\\?open=agent:)([^/?#&]+)/);
-    if (!match) {
-      throw new Error(`Expected workspace agent URL, got ${page.url()}`);
-    }
-    const serverId = decodeURIComponent(match[1]!);
-    const agentId = decodeURIComponent(match[2]!);
-    await expectComposerReady(page);
-    const initialCopyMessageCount = await page.getByRole('button', { name: 'Copy message' }).count();
-
-    await page.keyboard.press('Control+d');
-    await expectDictationStarted(page);
-
-    await page.keyboard.press('Control+d');
-
-    const newAgentButton = page.getByTestId('sidebar-new-agent');
-    await expect(newAgentButton).toBeVisible();
-    await newAgentButton.click();
-    await expect(page).toHaveURL(/\/h\/[^/]+\/new-agent(\?|$)/);
-
-    await page.waitForTimeout(10_000);
-
-    await page.goto(buildHostWorkspaceAgentRoute(serverId, repo.path, agentId));
-    await expect(page).toHaveURL(
-      new RegExp(`/h/${escapeRegex(serverId)}/workspace/[^?]+\\?open=agent(?:%3A|:)${escapeRegex(agentId)}(?:$|&)`)
-    );
-
-    await expect(page.getByRole('button', { name: 'Copy message' })).toHaveCount(initialCopyMessageCount);
-    await expect(page.getByTestId('agent-chat-scroll').getByText(/this is a voice note\./i)).toHaveCount(0);
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/draft-explorer-sidebar.spec.ts

@@ -1,42 +0,0 @@
-import { test, expect } from "./fixtures";
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-
-test("draft enables explorer after selecting a working directory", async ({ page }) => {
-  const repo = await createTempGitRepo("paseo-e2e-draft-explorer-");
-
-  try {
-    await gotoHome(page);
-    await ensureHostSelected(page);
-
-    const newAgentButton = page.getByTestId("sidebar-new-agent").first();
-    await expect(newAgentButton).toBeVisible({ timeout: 30000 });
-    await newAgentButton.click();
-    await expect(page).toHaveURL(/\/h\/[^/]+\/agent(\?|$)/, { timeout: 30000 });
-
-    await setWorkingDirectory(page, repo.path);
-
-    const toggle = page
-      .getByRole("button", {
-        name: /open explorer|close explorer|toggle explorer/i,
-      })
-      .first();
-    await expect(toggle).toBeVisible({ timeout: 30000 });
-
-    await toggle.click();
-    await expect(
-      page.locator('[data-testid="explorer-header"]:visible').first()
-    ).toBeVisible({ timeout: 30000 });
-
-    const terminalsTab = page
-      .locator('[data-testid="explorer-tab-terminals"]:visible')
-      .first();
-    await expect(terminalsTab).toBeVisible({ timeout: 30000 });
-    await terminalsTab.click();
-    await expect(
-      page.locator('[data-testid="terminal-surface"]:visible').first()
-    ).toBeVisible({ timeout: 30000 });
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/fixtures.ts

@@ -1,11 +1,12 @@
-import { test as base, expect, type Page } from '@playwright/test';
+import { test as base, expect, type Page } from "@playwright/test";
+import { buildCreateAgentPreferences, buildSeededHost } from "./helpers/daemon-registry";
 
 // Extend base test to provide dynamic baseURL from global-setup
 const test = base.extend({
   baseURL: async ({}, use) => {
     const metroPort = process.env.E2E_METRO_PORT;
     if (!metroPort) {
-      throw new Error('E2E_METRO_PORT not set - globalSetup must run first');
+      throw new Error("E2E_METRO_PORT not set - globalSetup must run first");
     }
     await use(`http://localhost:${metroPort}`);
   },
@@ -18,19 +19,19 @@ test.beforeEach(async ({ page }) => {
   const metroPort = process.env.E2E_METRO_PORT;
   if (!daemonPort) {
     throw new Error(
-      'E2E_DAEMON_PORT is not set. Refusing to run e2e against the default daemon (e.g. localhost:6767). ' +
-        'Ensure Playwright `globalSetup` starts the e2e daemon and exports E2E_DAEMON_PORT.'
+      "E2E_DAEMON_PORT is not set. Refusing to run e2e against the default daemon (e.g. localhost:6767). " +
+        "Ensure Playwright `globalSetup` starts the e2e daemon and exports E2E_DAEMON_PORT.",
     );
   }
-  if (daemonPort === '6767') {
+  if (daemonPort === "6767") {
     throw new Error(
-      'E2E_DAEMON_PORT is 6767. Refusing to run e2e against the default local daemon. ' +
-        'Fix Playwright globalSetup to start an isolated test daemon and export its port.'
+      "E2E_DAEMON_PORT is 6767. Refusing to run e2e against the default local daemon. " +
+        "Fix Playwright globalSetup to start an isolated test daemon and export its port.",
     );
   }
   if (!metroPort) {
     throw new Error(
-      'E2E_METRO_PORT is not set. Ensure Playwright `globalSetup` starts Metro and exports E2E_METRO_PORT.'
+      "E2E_METRO_PORT is not set. Ensure Playwright `globalSetup` starts Metro and exports E2E_METRO_PORT.",
     );
   }
 
@@ -38,17 +39,17 @@ test.beforeEach(async ({ page }) => {
   // This blocks both HTTP and WS attempts to :6767 (before any navigation).
   await page.route(/:(6767)\b/, (route) => route.abort());
   await page.routeWebSocket(/:(6767)\b/, async (ws) => {
-    await ws.close({ code: 1008, reason: 'Blocked connection to localhost:6767 during e2e.' });
+    await ws.close({ code: 1008, reason: "Blocked connection to localhost:6767 during e2e." });
   });
 
   const entries: string[] = [];
   consoleEntries.set(page, entries);
 
-  page.on('console', (message) => {
+  page.on("console", (message) => {
     entries.push(`[console:${message.type()}] ${message.text()}`);
   });
 
-  page.on('pageerror', (error) => {
+  page.on("pageerror", (error) => {
     entries.push(`[pageerror] ${error.message}`);
   });
 
@@ -56,40 +57,21 @@ test.beforeEach(async ({ page }) => {
   const seedNonce = Math.random().toString(36).slice(2);
   const serverId = process.env.E2E_SERVER_ID;
   if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set - expected from Playwright globalSetup.');
+    throw new Error("E2E_SERVER_ID is not set - expected from Playwright globalSetup.");
   }
-  const testDaemon = {
+  const testDaemon = buildSeededHost({
     serverId,
-    label: 'localhost',
-    connections: [
-      {
-        id: `direct:127.0.0.1:${daemonPort}`,
-        type: 'direct',
-        endpoint: `127.0.0.1:${daemonPort}`,
-      },
-    ],
-    preferredConnectionId: `direct:127.0.0.1:${daemonPort}`,
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  const createAgentPreferences = {
-    // Ensure create flow never uses a remembered host from the developer's real app.
-    serverId: testDaemon.serverId,
-    // Keep e2e fast/cheap by default.
-    provider: 'codex',
-    providerPreferences: {
-      claude: { model: 'haiku' },
-      codex: { model: 'gpt-5.1-codex-mini', thinkingOptionId: 'low' },
-    },
-  };
+    endpoint: `127.0.0.1:${daemonPort}`,
+    nowIso,
+  });
+  const createAgentPreferences = buildCreateAgentPreferences(testDaemon.serverId);
 
   await page.addInitScript(
     ({ daemon, preferences, seedNonce }) => {
       // `addInitScript` runs on every navigation (including reloads). Some tests intentionally
       // override storage and reload; they can opt out of seeding for the *next* navigation by
       // setting this flag before the reload.
-      const disableOnceKey = '@paseo:e2e-disable-default-seed-once';
+      const disableOnceKey = "@paseo:e2e-disable-default-seed-once";
       const disableValue = localStorage.getItem(disableOnceKey);
       if (disableValue) {
         localStorage.removeItem(disableOnceKey);
@@ -98,15 +80,15 @@ test.beforeEach(async ({ page }) => {
         }
       }
 
-      localStorage.setItem('@paseo:e2e', '1');
-      localStorage.setItem('@paseo:e2e-seed-nonce', seedNonce);
+      localStorage.setItem("@paseo:e2e", "1");
+      localStorage.setItem("@paseo:e2e-seed-nonce", seedNonce);
 
       // Hard-reset anything that could point to a developer's real daemon.
-      localStorage.setItem('@paseo:daemon-registry', JSON.stringify([daemon]));
-      localStorage.removeItem('@paseo:settings');
-      localStorage.setItem('@paseo:create-agent-preferences', JSON.stringify(preferences));
+      localStorage.setItem("@paseo:daemon-registry", JSON.stringify([daemon]));
+      localStorage.removeItem("@paseo:settings");
+      localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
     },
-    { daemon: testDaemon, preferences: createAgentPreferences, seedNonce }
+    { daemon: testDaemon, preferences: createAgentPreferences, seedNonce },
   );
 });
 
@@ -120,9 +102,9 @@ test.afterEach(async ({ page }, testInfo) => {
     return;
   }
 
-  await testInfo.attach('browser-console', {
-    body: entries.join('\n'),
-    contentType: 'text/plain',
+  await testInfo.attach("browser-console", {
+    body: entries.join("\n"),
+    contentType: "text/plain",
   });
 });
 

packages/app/e2e/git-diff-sticky-headers.spec.ts

@@ -1,119 +0,0 @@
-import path from 'node:path';
-import { appendFile } from 'node:fs/promises';
-import { test, expect, type Page } from './fixtures';
-import { createAgent, ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test.describe.configure({ timeout: 90000 });
-
-function getChangesScope(page: Page) {
-  return page.locator('[data-testid="explorer-content-area"]:visible').first();
-}
-
-async function ensureExplorerTabsVisible(page: Page) {
-  const changesTab = page.getByTestId('explorer-tab-changes').first();
-  if (await changesTab.isVisible().catch(() => false)) {
-    return;
-  }
-
-  const toggle = page
-    .getByRole('button', { name: /open explorer|close explorer|toggle explorer/i })
-    .first();
-  await expect(toggle).toBeVisible({ timeout: 10000 });
-  for (let attempt = 0; attempt < 4; attempt += 1) {
-    if (await changesTab.isVisible().catch(() => false)) {
-      return;
-    }
-    await toggle.click();
-    await page.waitForTimeout(200);
-  }
-  await expect(changesTab).toBeVisible({ timeout: 30000 });
-}
-
-async function openChangesPanel(page: Page) {
-  await ensureExplorerTabsVisible(page);
-  const changesHeader = getChangesScope(page).getByTestId('changes-header');
-  if (!(await changesHeader.isVisible())) {
-    await page.getByTestId('explorer-tab-changes').first().click();
-  }
-  await expect(changesHeader).toBeVisible();
-}
-
-async function refreshUncommittedMode(page: Page) {
-  const scope = getChangesScope(page);
-  const toggle = scope.getByTestId('changes-diff-status').first();
-  await expect(toggle).toBeVisible({ timeout: 30000 });
-
-  const diffModeBackdrop = page.getByTestId('changes-diff-status-menu-backdrop');
-  if (await diffModeBackdrop.isVisible().catch(() => false)) {
-    await diffModeBackdrop.click({ force: true });
-    await expect(diffModeBackdrop).toHaveCount(0);
-  }
-
-  const currentLabel = (await toggle.innerText()).trim();
-  await toggle.click({ force: true });
-  await expect(page.getByTestId('changes-diff-status-menu')).toBeVisible({ timeout: 10000 });
-  const firstTarget = currentLabel === 'Uncommitted' ? 'changes-diff-mode-committed' : 'changes-diff-mode-uncommitted';
-  await page.getByTestId(firstTarget).click({ force: true });
-  await expect.poll(async () => (await toggle.innerText()).trim()).not.toBe(currentLabel);
-
-  const nextLabel = (await toggle.innerText()).trim();
-  await toggle.click({ force: true });
-  await expect(page.getByTestId('changes-diff-status-menu')).toBeVisible({ timeout: 10000 });
-  const secondTarget = nextLabel === 'Uncommitted' ? 'changes-diff-mode-committed' : 'changes-diff-mode-uncommitted';
-  await page.getByTestId(secondTarget).click({ force: true });
-  await expect.poll(async () => (await toggle.innerText()).trim()).not.toBe(nextLabel);
-}
-
-async function createAgentAndWait(page: Page, message: string) {
-  await createAgent(page, message);
-}
-
-test('keeps file header sticky while scrolling within a long diff', async ({ page }) => {
-  const repo = await createTempGitRepo('paseo-e2e-sticky-');
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-    await createAgentAndWait(page, 'Respond with exactly: READY');
-
-    await openChangesPanel(page);
-
-    const readmePath = path.join(repo.path, 'README.md');
-    const lines = Array.from({ length: 400 }, (_, idx) => `Sticky header line ${idx}\n`).join('');
-    await appendFile(readmePath, `\n${lines}`);
-
-    await refreshUncommittedMode(page);
-
-    const scope = getChangesScope(page);
-    await expect(scope.getByText('README.md', { exact: true })).toBeVisible({ timeout: 30000 });
-
-    const fileToggle = scope.getByTestId('diff-file-0-toggle').first();
-    await fileToggle.click();
-
-    const markerLine = scope.getByText('Sticky header line 250').first();
-    await expect(markerLine).toBeVisible({ timeout: 30000 });
-
-    const scroll = scope.getByTestId('git-diff-scroll').first();
-    await expect(scroll).toBeVisible();
-
-    await expect.poll(async () => {
-      return await scroll.evaluate((el) => (el.scrollHeight ?? 0) > (el.clientHeight ?? 0));
-    }).toBe(true);
-
-    await scroll.hover();
-    for (let i = 0; i < 12; i++) {
-      await page.mouse.wheel(0, 700);
-    }
-
-    await expect.poll(async () => {
-      return await scroll.evaluate((el) => el.scrollTop ?? 0);
-    }).toBeGreaterThan(0);
-
-    await expect(scope.getByText('Sticky header line 390').first()).toBeVisible({ timeout: 30000 });
-    await expect(fileToggle).toBeVisible();
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/global-draft-create-status-controls.spec.ts

@@ -1,47 +0,0 @@
-import { test, expect } from './fixtures'
-import { createTempGitRepo } from './helpers/workspace'
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app'
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-test('global draft create uses input status controls and preserves optimistic flow', async ({ page }) => {
-  const repo = await createTempGitRepo('paseo-e2e-global-draft-')
-  const prompt = `global draft prompt ${Date.now()}`
-
-  try {
-    await gotoHome(page)
-    await ensureHostSelected(page)
-    await setWorkingDirectory(page, repo.path)
-
-    await expect(page.getByTestId('working-directory-select').first()).toBeVisible({ timeout: 30_000 })
-
-    const providerSelector = page.getByTestId('agent-provider-selector').first()
-    const modeSelector = page.getByTestId('agent-mode-selector').first()
-    const modelSelector = page.getByTestId('agent-model-selector').first()
-    const thinkingSelector = page.getByTestId('agent-thinking-selector').first()
-
-    await expect(providerSelector).toBeVisible({ timeout: 30_000 })
-    await expect(modeSelector).toBeVisible({ timeout: 30_000 })
-    await expect(modelSelector).toBeVisible({ timeout: 30_000 })
-    await expect(thinkingSelector).toBeVisible({ timeout: 30_000 })
-
-    const selectedMode = ((await modeSelector.innerText()) ?? '').trim()
-    const selectedModel = ((await modelSelector.innerText()) ?? '').trim()
-    const selectedThinking = ((await thinkingSelector.innerText()) ?? '').trim()
-
-    const composer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await composer.fill(prompt)
-    await composer.press('Enter')
-
-    await expect(page.getByText(prompt, { exact: true }).first()).toBeVisible({ timeout: 5_000 })
-    await expect(page).toHaveURL(/\/workspace\//, { timeout: 30_000 })
-
-    await expect(modelSelector).toContainText(new RegExp(escapeRegex(selectedModel), 'i'))
-    await expect(modeSelector).toContainText(new RegExp(escapeRegex(selectedMode), 'i'))
-    await expect(thinkingSelector).toContainText(new RegExp(escapeRegex(selectedThinking), 'i'))
-  } finally {
-    await repo.cleanup()
-  }
-})

packages/app/e2e/global-draft-to-existing-workspace-redirect.spec.ts

@@ -1,219 +0,0 @@
-import { test, expect } from './fixtures'
-import type { Page } from '@playwright/test'
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app'
-import { createTempGitRepo } from './helpers/workspace'
-import { getWorkspaceTabTestIds } from './helpers/workspace-tabs'
-
-function parseWorkspaceContextFromUrl(rawUrl: string): { workspaceToken: string | null; agentId: string | null } {
-  const url = new URL(rawUrl)
-  const pathMatch = url.pathname.match(/\/workspace\/([^/?#]+)(?:\/agent\/([^/?#]+))?/) ?? null
-  const workspaceToken = pathMatch?.[1] ?? null
-  let agentId = pathMatch?.[2] ?? null
-
-  if (!agentId) {
-    const open = url.searchParams.get('open')
-    const openMatch = open?.match(/^agent:(.+)$/) ?? null
-    if (openMatch?.[1]) {
-      agentId = openMatch[1]
-    }
-  }
-
-  return { workspaceToken, agentId }
-}
-
-function getOpenAgentIdFromUrl(rawUrl: string): string | null {
-  const url = new URL(rawUrl)
-  const open = url.searchParams.get('open')
-  const openMatch = open?.match(/^agent:(.+)$/) ?? null
-  return openMatch?.[1] ?? null
-}
-
-async function preferSlowerThinkingOption(page: Page): Promise<void> {
-  await page.keyboard.press('Escape').catch(() => undefined)
-  const thinkingTrigger = page.getByTestId('agent-thinking-selector').first()
-  if (!(await thinkingTrigger.isVisible().catch(() => false))) {
-    return
-  }
-  await thinkingTrigger.click({ force: true })
-  const menu = page.getByTestId('agent-thinking-menu').first()
-  if (!(await menu.isVisible().catch(() => false))) {
-    return
-  }
-
-  const preferred = ['high', 'max', 'deep', 'long', 'medium']
-  for (const label of preferred) {
-    const option = menu.getByRole('button', { name: new RegExp(`^${label}$`, 'i') }).first()
-    if (await option.isVisible().catch(() => false)) {
-      await option.click({ force: true })
-      await expect(menu).not.toBeVisible({ timeout: 5_000 })
-      return
-    }
-  }
-
-  const options = menu.getByRole('button')
-  const count = await options.count()
-  if (count > 0) {
-    await options.last().click({ force: true })
-  }
-  await expect(menu).not.toBeVisible({ timeout: 5_000 })
-}
-
-async function isAnyStopVisible(page: Page): Promise<boolean> {
-  const candidates = page.getByRole('button', { name: /stop|cancel/i })
-  const count = await candidates.count()
-  for (let index = 0; index < count; index += 1) {
-    if (await candidates.nth(index).isVisible().catch(() => false)) {
-      return true
-    }
-  }
-  return false
-}
-
-async function isRunningControlVisible(page: Page): Promise<boolean> {
-  if (await isAnyStopVisible(page)) {
-    return true
-  }
-  const interruptSendButton = page.getByRole('button', { name: /interrupt agent|send and interrupt/i })
-  const count = await interruptSendButton.count()
-  for (let index = 0; index < count; index += 1) {
-    if (await interruptSendButton.nth(index).isVisible().catch(() => false)) {
-      return true
-    }
-  }
-  return false
-}
-
-async function hasVisibleText(page: Page, matcher: RegExp | string): Promise<boolean> {
-  const locator = page.getByText(matcher).first()
-  const matches = page.getByText(matcher)
-  const count = await matches.count()
-  for (let index = 0; index < count; index += 1) {
-    if (await matches.nth(index).isVisible().catch(() => false)) {
-      return true
-    }
-  }
-  return await locator.isVisible().catch(() => false)
-}
-
-test('global draft create in existing workspace redirects to that workspace with created agent tab and settles to idle', async ({
-  page,
-}) => {
-  test.setTimeout(360_000)
-  const serverId = process.env.E2E_SERVER_ID
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set.')
-  }
-
-  const repo = await createTempGitRepo('paseo-e2e-global-existing-workspace-')
-  const id = `${Date.now()}`
-  const seedPrompt = `hello seed-${id}. please reply exactly: ACK_SEED_${id}`
-  const secondPrompt = `hello second-${id}. please reply exactly: ACK_SECOND_${id}`
-  const lifecyclePrompt = `hello lifecycle-${id}. wait 8 seconds, then reply exactly: ACK_LIFECYCLE_${id}`
-  const seedToken = `ACK_SEED_${id}`
-  const secondToken = `ACK_SECOND_${id}`
-  expect(seedPrompt).not.toBe(secondPrompt)
-  expect(seedToken).not.toBe(secondToken)
-
-  try {
-    await gotoHome(page)
-    await ensureHostSelected(page)
-    await page.goto(`/h/${serverId}/new-agent`)
-    await expect(page.locator('[data-testid="working-directory-select"]:visible').first()).toBeVisible({
-      timeout: 30_000,
-    })
-
-    // 1) Seed workspace with an existing agent.
-    await setWorkingDirectory(page, repo.path)
-    const seedComposer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await seedComposer.fill(seedPrompt)
-    await seedComposer.press('Enter')
-
-    await expect(page.getByText(seedPrompt, { exact: true }).first()).toBeVisible({ timeout: 30_000 })
-    await expect(page).toHaveURL(/\/workspace\//, { timeout: 60_000 })
-    const seededContext = parseWorkspaceContextFromUrl(page.url())
-    if (!seededContext.workspaceToken || !seededContext.agentId) {
-      throw new Error(`Expected seeded workspace token and agent id in URL, got: ${page.url()}`)
-    }
-    const seededAgentId = seededContext.agentId
-    expect(getOpenAgentIdFromUrl(page.url())).toBe(seededAgentId)
-    await expect(page.getByText(new RegExp(seedToken)).first()).toBeVisible({ timeout: 180_000 })
-
-    // 2) Use global New Agent entry and 3) select same workspace.
-    await page.getByText('New agent', { exact: true }).first().click()
-    await expect(page).toHaveURL(new RegExp(`/h/${serverId}/new-agent`), { timeout: 30_000 })
-    await expect(page.locator('[data-testid="working-directory-select"]:visible').first()).toBeVisible({
-      timeout: 30_000,
-    })
-
-    await setWorkingDirectory(page, repo.path)
-    await preferSlowerThinkingOption(page)
-    await page.keyboard.press('Escape').catch(() => undefined)
-
-    // 4) Create second agent from global draft.
-    const composer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await composer.fill(secondPrompt)
-    await composer.press('Enter')
-    await page.waitForTimeout(500)
-    if (page.url().includes('/new-agent')) {
-      const sendButton = page.getByRole('button', { name: /send message/i }).first()
-      await expect(sendButton).toBeVisible({ timeout: 10_000 })
-      await expect(sendButton).toBeEnabled({ timeout: 10_000 })
-      await sendButton.click({ force: true })
-    }
-
-    // 5) Assert redirect workspace context + created agent tab is active/open.
-    await expect(page).toHaveURL(/\/workspace\//, { timeout: 60_000 })
-    const createdContext = parseWorkspaceContextFromUrl(page.url())
-    expect(createdContext.workspaceToken).toBe(seededContext.workspaceToken)
-    if (!createdContext.agentId) {
-      throw new Error(`Expected created agent id in URL, got: ${page.url()}`)
-    }
-    const createdAgentId = createdContext.agentId
-    expect(createdAgentId).toBeTruthy()
-    expect(createdAgentId).not.toBe(seededAgentId)
-    expect(getOpenAgentIdFromUrl(page.url())).toBe(createdAgentId)
-    expect(getOpenAgentIdFromUrl(page.url())).not.toBe(seededAgentId)
-
-    const createdTabTestId = `workspace-tab-agent_${createdAgentId}`
-    await expect
-      .poll(async () => {
-        const finalTabIds = await getWorkspaceTabTestIds(page)
-        return finalTabIds.includes(createdTabTestId)
-      })
-      .toBe(true)
-    expect(getOpenAgentIdFromUrl(page.url())).toBe(createdAgentId)
-
-    // 6) Response assertions are scoped to created-agent active context.
-    await expect
-      .poll(async () => hasVisibleText(page, new RegExp(secondToken)), { timeout: 240_000 })
-      .toBe(true)
-    await expect(page.getByText(seedToken, { exact: true }).first()).not.toBeVisible({ timeout: 30_000 })
-
-    // 7) Lifecycle assertions on created agent only: running first, then idle.
-    const lifecycleComposer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await lifecycleComposer.fill(lifecyclePrompt)
-    await lifecycleComposer.press('Enter')
-    await expect
-      .poll(async () => hasVisibleText(page, lifecyclePrompt), { timeout: 30_000 })
-      .toBe(true)
-
-    let sawRunning = false
-    for (let attempt = 0; attempt < 1200; attempt += 1) {
-      if (await isRunningControlVisible(page)) {
-        sawRunning = true
-        break
-      }
-      await page.waitForTimeout(50)
-    }
-    expect(sawRunning).toBe(true)
-
-    await expect
-      .poll(async () => (await isRunningControlVisible(page)) === false, { timeout: 240_000 })
-      .toBe(true)
-    const idleComposer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await expect(idleComposer).toBeVisible({ timeout: 30_000 })
-    await expect(idleComposer).toBeEditable({ timeout: 30_000 })
-  } finally {
-    await repo.cleanup()
-  }
-})

packages/app/e2e/global-setup.ts

@@ -1,11 +1,11 @@
-import { spawn, type ChildProcess, execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import net from 'node:net';
-import { Buffer } from 'node:buffer';
-import dotenv from 'dotenv';
+import { spawn, type ChildProcess, execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import net from "node:net";
+import { Buffer } from "node:buffer";
+import dotenv from "dotenv";
 
 type WaitForServerOptions = {
   host?: string;
@@ -18,11 +18,11 @@ type WaitForServerOptions = {
 async function getAvailablePort(): Promise<number> {
   return new Promise((resolve, reject) => {
     const server = net.createServer();
-    server.once('error', reject);
+    server.once("error", reject);
     server.listen(0, () => {
       const address = server.address();
-      if (!address || typeof address === 'string') {
-        server.close(() => reject(new Error('Failed to acquire port')));
+      if (!address || typeof address === "string") {
+        server.close(() => reject(new Error("Failed to acquire port")));
         return;
       }
       server.close(() => resolve(address.port));
@@ -40,18 +40,18 @@ function createLineBuffer(maxLines = 120): { add: (line: string) => void; dump:
       }
     },
     dump() {
-      return lines.join('\n');
+      return lines.join("\n");
     },
   };
 }
 
 function formatRecentOutput(getRecentOutput?: () => string): string {
   if (!getRecentOutput) {
-    return '';
+    return "";
   }
   const output = getRecentOutput().trim();
   if (!output) {
-    return '';
+    return "";
   }
   return `\nRecent output:\n${output}`;
 }
@@ -61,21 +61,15 @@ function sleep(ms: number): Promise<void> {
 }
 
 async function waitForServer(port: number, options: WaitForServerOptions): Promise<void> {
-  const {
-    host = '127.0.0.1',
-    timeoutMs = 15000,
-    label,
-    childProcess,
-    getRecentOutput,
-  } = options;
+  const { host = "127.0.0.1", timeoutMs = 15000, label, childProcess, getRecentOutput } = options;
   const start = Date.now();
   let lastConnectionError: unknown = null;
 
   while (Date.now() - start < timeoutMs) {
     if (childProcess && childProcess.exitCode !== null) {
-      const signal = childProcess.signalCode ? `, signal ${childProcess.signalCode}` : '';
+      const signal = childProcess.signalCode ? `, signal ${childProcess.signalCode}` : "";
       throw new Error(
-        `${label} exited before listening on ${host}:${port} (exit code ${childProcess.exitCode}${signal}).${formatRecentOutput(getRecentOutput)}`
+        `${label} exited before listening on ${host}:${port} (exit code ${childProcess.exitCode}${signal}).${formatRecentOutput(getRecentOutput)}`,
       );
     }
 
@@ -89,7 +83,7 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
           socket.destroy();
           reject(new Error(`Connection timed out to ${host}:${port}`));
         });
-        socket.on('error', reject);
+        socket.on("error", reject);
       });
       return;
     } catch (error) {
@@ -99,9 +93,11 @@ async function waitForServer(port: number, options: WaitForServerOptions): Promi
   }
 
   const reason =
-    lastConnectionError instanceof Error ? ` Last connection error: ${lastConnectionError.message}` : '';
+    lastConnectionError instanceof Error
+      ? ` Last connection error: ${lastConnectionError.message}`
+      : "";
   throw new Error(
-    `${label} did not start on ${host}:${port} within ${timeoutMs}ms.${reason}${formatRecentOutput(getRecentOutput)}`
+    `${label} did not start on ${host}:${port} within ${timeoutMs}ms.${reason}${formatRecentOutput(getRecentOutput)}`,
   );
 }
 
@@ -126,15 +122,15 @@ async function stopProcess(child: ChildProcess | null): Promise<void> {
   if (child.exitCode !== null || child.signalCode !== null) {
     return;
   }
-  child.kill('SIGTERM');
+  child.kill("SIGTERM");
   await new Promise<void>((resolve) => {
     const timeout = setTimeout(() => {
       if (child.exitCode === null && child.signalCode === null) {
-        child.kill('SIGKILL');
+        child.kill("SIGKILL");
       }
       resolve();
     }, 5000);
-    child.once('exit', () => {
+    child.once("exit", () => {
       clearTimeout(timeout);
       resolve();
     });
@@ -144,7 +140,7 @@ async function stopProcess(child: ChildProcess | null): Promise<void> {
 function summarizeOpenAiErrorBody(body: string): string {
   const trimmed = body.trim();
   if (!trimmed) {
-    return 'empty response body';
+    return "empty response body";
   }
   if (trimmed.length <= 240) {
     return trimmed;
@@ -159,8 +155,8 @@ async function isOpenAiApiKeyUsable(apiKey: string | undefined): Promise<boolean
   }
 
   try {
-    const response = await fetch('https://api.openai.com/v1/models?limit=1', {
-      method: 'GET',
+    const response = await fetch("https://api.openai.com/v1/models?limit=1", {
+      method: "GET",
       headers: {
         Authorization: `Bearer ${key}`,
       },
@@ -170,14 +166,14 @@ async function isOpenAiApiKeyUsable(apiKey: string | undefined): Promise<boolean
     }
     const body = await response.text();
     console.warn(
-      `[e2e] OPENAI_API_KEY probe failed (${response.status}): ${summarizeOpenAiErrorBody(body)}`
+      `[e2e] OPENAI_API_KEY probe failed (${response.status}): ${summarizeOpenAiErrorBody(body)}`,
     );
     return false;
   } catch (error) {
     console.warn(
       `[e2e] OPENAI_API_KEY probe request failed: ${
         error instanceof Error ? error.message : String(error)
-      }`
+      }`,
     );
     return false;
   }
@@ -196,28 +192,42 @@ type OfferPayload = {
 };
 
 function stripAnsi(input: string): string {
-  return input.replace(/\u001b\[[0-9;]*m/g, '');
+  return input.replace(/\u001b\[[0-9;]*m/g, "");
+}
+
+function ensureRelayBuildArtifact(repoRoot: string): void {
+  const relayDistEntry = path.join(repoRoot, "packages/relay/dist/e2ee.js");
+  if (existsSync(relayDistEntry)) {
+    return;
+  }
+
+  console.log("[e2e] Building @getpaseo/relay for daemon startup");
+  execSync("npm run build --workspace=@getpaseo/relay", {
+    cwd: repoRoot,
+    stdio: "inherit",
+  });
 }
 
 function decodeOfferFromFragmentUrl(url: string): OfferPayload {
-  const marker = '#offer=';
+  const marker = "#offer=";
   const idx = url.indexOf(marker);
   if (idx === -1) {
     throw new Error(`missing ${marker} fragment: ${url}`);
   }
   const encoded = url.slice(idx + marker.length);
-  const json = Buffer.from(encoded, 'base64url').toString('utf8');
+  const json = Buffer.from(encoded, "base64url").toString("utf8");
   const offer = JSON.parse(json) as Partial<OfferPayload>;
-  if (offer.v !== 2) throw new Error('offer.v missing/invalid');
-  if (!offer.serverId) throw new Error('offer.serverId missing');
-  if (!offer.daemonPublicKeyB64) throw new Error('offer.daemonPublicKeyB64 missing');
-  if (!offer.relay?.endpoint) throw new Error('offer.relay.endpoint missing');
+  if (offer.v !== 2) throw new Error("offer.v missing/invalid");
+  if (!offer.serverId) throw new Error("offer.serverId missing");
+  if (!offer.daemonPublicKeyB64) throw new Error("offer.daemonPublicKeyB64 missing");
+  if (!offer.relay?.endpoint) throw new Error("offer.relay.endpoint missing");
   return offer as OfferPayload;
 }
 
 export default async function globalSetup() {
-  const repoRoot = path.resolve(__dirname, '../../..');
-  const envTestPath = path.join(repoRoot, '.env.test');
+  const repoRoot = path.resolve(__dirname, "../../..");
+  ensureRelayBuildArtifact(repoRoot);
+  const envTestPath = path.join(repoRoot, ".env.test");
   if (existsSync(envTestPath)) {
     dotenv.config({ path: envTestPath });
   }
@@ -225,13 +235,17 @@ export default async function globalSetup() {
   const port = await getAvailablePort();
   let relayPort = 0;
   const metroPort = await getAvailablePort();
-  paseoHome = await mkdtemp(path.join(tmpdir(), 'paseo-e2e-home-'));
+  paseoHome = await mkdtemp(path.join(tmpdir(), "paseo-e2e-home-"));
   let relayLineBuffer = createLineBuffer();
   const metroLineBuffer = createLineBuffer();
   const daemonLineBuffer = createLineBuffer();
 
   const cleanup = async () => {
-    await Promise.all([stopProcess(daemonProcess), stopProcess(metroProcess), stopProcess(relayProcess)]);
+    await Promise.all([
+      stopProcess(daemonProcess),
+      stopProcess(metroProcess),
+      stopProcess(relayProcess),
+    ]);
     daemonProcess = null;
     metroProcess = null;
     relayProcess = null;
@@ -242,24 +256,30 @@ export default async function globalSetup() {
   };
 
   const openAiUsable = await isOpenAiApiKeyUsable(process.env.OPENAI_API_KEY);
-  const defaultLocalModelsDir = path.join(process.env.HOME ?? '', '.paseo', 'models', 'local-speech');
-  const hasDefaultLocalModelsDir = defaultLocalModelsDir.trim().length > 0 && existsSync(defaultLocalModelsDir);
-  const dictationProvider = openAiUsable ? 'openai' : 'local';
+  const defaultLocalModelsDir = path.join(
+    process.env.HOME ?? "",
+    ".paseo",
+    "models",
+    "local-speech",
+  );
+  const hasDefaultLocalModelsDir =
+    defaultLocalModelsDir.trim().length > 0 && existsSync(defaultLocalModelsDir);
+  const dictationProvider = openAiUsable ? "openai" : "local";
 
-  if (dictationProvider === 'local' && !hasDefaultLocalModelsDir) {
+  if (dictationProvider === "local" && !hasDefaultLocalModelsDir) {
     throw new Error(
-      'OpenAI key is not usable and local speech models are unavailable at ~/.paseo/models/local-speech. ' +
-        'Either provide a valid OPENAI_API_KEY or install local speech models before running app e2e tests.'
+      "OpenAI key is not usable and local speech models are unavailable at ~/.paseo/models/local-speech. " +
+        "Either provide a valid OPENAI_API_KEY or install local speech models before running app e2e tests.",
     );
   }
 
-  const localModelsDir = dictationProvider === 'local' ? defaultLocalModelsDir : null;
+  const localModelsDir = dictationProvider === "local" ? defaultLocalModelsDir : null;
   console.log(
-    `[e2e] Dictation STT provider: ${dictationProvider}${openAiUsable ? '' : ' (OpenAI probe failed)'}`
+    `[e2e] Dictation STT provider: ${dictationProvider}${openAiUsable ? "" : " (OpenAI probe failed)"}`,
   );
 
   try {
-    const relayDir = path.resolve(__dirname, '..', '..', 'relay');
+    const relayDir = path.resolve(__dirname, "..", "..", "relay");
     const maxRelayStartupAttempts = 5;
     let relayStarted = false;
     let lastRelayStartupError: unknown = null;
@@ -271,18 +291,21 @@ export default async function globalSetup() {
       let relayReadyForSelectedPort = false;
 
       relayProcess = spawn(
-        'npx',
-        ['wrangler', 'dev', '--local', '--ip', '127.0.0.1', '--port', String(relayPort)],
+        "npx",
+        ["wrangler", "dev", "--local", "--ip", "127.0.0.1", "--port", String(relayPort)],
         {
           cwd: relayDir,
           env: { ...process.env },
-          stdio: ['ignore', 'pipe', 'pipe'],
+          stdio: ["ignore", "pipe", "pipe"],
           detached: false,
-        }
+        },
       );
 
-      relayProcess.stdout?.on('data', (data: Buffer) => {
-        const lines = data.toString().split('\n').filter((line) => line.trim());
+      relayProcess.stdout?.on("data", (data: Buffer) => {
+        const lines = data
+          .toString()
+          .split("\n")
+          .filter((line) => line.trim());
         for (const line of lines) {
           relayLineBuffer.add(`[stdout] ${line}`);
           const failure = parseRelayStartupFailure(line);
@@ -297,8 +320,11 @@ export default async function globalSetup() {
           console.log(`[relay] ${line}`);
         }
       });
-      relayProcess.stderr?.on('data', (data: Buffer) => {
-        const lines = data.toString().split('\n').filter((line) => line.trim());
+      relayProcess.stderr?.on("data", (data: Buffer) => {
+        const lines = data
+          .toString()
+          .split("\n")
+          .filter((line) => line.trim());
         for (const line of lines) {
           relayLineBuffer.add(`[stderr] ${line}`);
           const failure = parseRelayStartupFailure(line);
@@ -316,7 +342,7 @@ export default async function globalSetup() {
 
       try {
         await waitForServer(relayPort, {
-          label: 'Relay dev server',
+          label: "Relay dev server",
           timeoutMs: 30000,
           childProcess: relayProcess,
           getRecentOutput: relayLineBuffer.dump,
@@ -339,15 +365,15 @@ export default async function globalSetup() {
         if (!relayReadyForSelectedPort) {
           throw new Error(
             `Relay process did not report ready for selected port ${relayPort}.${formatRecentOutput(
-              relayLineBuffer.dump
-            )}`
+              relayLineBuffer.dump,
+            )}`,
           );
         }
         if (relayProcess.exitCode !== null || relayProcess.signalCode !== null) {
           throw new Error(
             `Relay process exited before startup completed (exit code ${relayProcess.exitCode}, signal ${relayProcess.signalCode}).${formatRecentOutput(
-              relayLineBuffer.dump
-            )}`
+              relayLineBuffer.dump,
+            )}`,
           );
         }
 
@@ -366,40 +392,46 @@ export default async function globalSetup() {
           ? lastRelayStartupError.message
           : String(lastRelayStartupError);
       throw new Error(
-        `Failed to start relay dev server after ${maxRelayStartupAttempts} attempts. ${message}`
+        `Failed to start relay dev server after ${maxRelayStartupAttempts} attempts. ${message}`,
       );
     }
 
     // Start Metro bundler on dynamic port
-    const appDir = path.resolve(__dirname, '..');
-    metroProcess = spawn('npx', ['expo', 'start', '--web', '--port', String(metroPort)], {
+    const appDir = path.resolve(__dirname, "..");
+    metroProcess = spawn("npx", ["expo", "start", "--web", "--port", String(metroPort)], {
       cwd: appDir,
       env: {
         ...process.env,
-        BROWSER: 'none', // Don't auto-open browser
+        BROWSER: "none", // Don't auto-open browser
       },
-      stdio: ['ignore', 'pipe', 'pipe'],
+      stdio: ["ignore", "pipe", "pipe"],
       detached: false,
     });
 
-    metroProcess.stdout?.on('data', (data: Buffer) => {
-      const lines = data.toString().split('\n').filter((line) => line.trim());
+    metroProcess.stdout?.on("data", (data: Buffer) => {
+      const lines = data
+        .toString()
+        .split("\n")
+        .filter((line) => line.trim());
       for (const line of lines) {
         metroLineBuffer.add(`[stdout] ${line}`);
         console.log(`[metro] ${line}`);
       }
     });
 
-    metroProcess.stderr?.on('data', (data: Buffer) => {
-      const lines = data.toString().split('\n').filter((line) => line.trim());
+    metroProcess.stderr?.on("data", (data: Buffer) => {
+      const lines = data
+        .toString()
+        .split("\n")
+        .filter((line) => line.trim());
       for (const line of lines) {
         metroLineBuffer.add(`[stderr] ${line}`);
         console.error(`[metro] ${line}`);
       }
     });
 
-    const serverDir = path.resolve(__dirname, '../../..', 'packages/server');
-    const tsxBin = execSync('which tsx').toString().trim();
+    const serverDir = path.resolve(__dirname, "../../..", "packages/server");
+    const tsxBin = execSync("which tsx").toString().trim();
 
     let offerPayload: OfferPayload | null = null;
     let offerResolve: (() => void) | null = null;
@@ -407,33 +439,36 @@ export default async function globalSetup() {
       offerResolve = resolve;
     });
 
-    daemonProcess = spawn(tsxBin, ['src/server/index.ts'], {
+    daemonProcess = spawn(tsxBin, ["src/server/index.ts"], {
       cwd: serverDir,
       env: {
         ...process.env,
         PASEO_HOME: paseoHome,
-        PASEO_SERVER_ID: 'srv_e2e_test_daemon',
+        PASEO_SERVER_ID: "srv_e2e_test_daemon",
         PASEO_LISTEN: `0.0.0.0:${port}`,
         PASEO_RELAY_ENDPOINT: `127.0.0.1:${relayPort}`,
         PASEO_CORS_ORIGINS: `http://localhost:${metroPort}`,
-        // Use OpenAI speech providers in e2e to avoid local model bootstrapping delays.
-        PASEO_DICTATION_ENABLED: '1',
-        PASEO_VOICE_MODE_ENABLED: '1',
-        PASEO_DICTATION_STT_PROVIDER: dictationProvider,
-        PASEO_VOICE_STT_PROVIDER: 'openai',
-        PASEO_VOICE_TTS_PROVIDER: 'openai',
+        PASEO_DICTATION_ENABLED: openAiUsable ? "1" : "0",
+        PASEO_VOICE_MODE_ENABLED: openAiUsable ? "1" : "0",
+        ...(openAiUsable
+          ? {
+              PASEO_DICTATION_STT_PROVIDER: "openai",
+              PASEO_VOICE_STT_PROVIDER: "openai",
+              PASEO_VOICE_TTS_PROVIDER: "openai",
+            }
+          : {}),
         ...(localModelsDir ? { PASEO_LOCAL_MODELS_DIR: localModelsDir } : {}),
-        NODE_ENV: 'development',
+        NODE_ENV: "development",
       },
-      stdio: ['ignore', 'pipe', 'pipe'],
+      stdio: ["ignore", "pipe", "pipe"],
       detached: false,
     });
 
-    let stdoutBuffer = '';
-    daemonProcess.stdout?.on('data', (data: Buffer) => {
-      stdoutBuffer += data.toString('utf8');
-      const lines = stdoutBuffer.split('\n');
-      stdoutBuffer = lines.pop() ?? '';
+    let stdoutBuffer = "";
+    daemonProcess.stdout?.on("data", (data: Buffer) => {
+      stdoutBuffer += data.toString("utf8");
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() ?? "";
       for (const line of lines) {
         const trimmed = line.trim();
         if (!trimmed) continue;
@@ -442,13 +477,13 @@ export default async function globalSetup() {
           const clean = stripAnsi(trimmed);
           try {
             const obj = JSON.parse(clean) as { msg?: string; url?: string };
-            if (obj.msg === 'pairing_offer' && typeof obj.url === 'string') {
+            if (obj.msg === "pairing_offer" && typeof obj.url === "string") {
               offerPayload = decodeOfferFromFragmentUrl(obj.url);
               offerResolve?.();
             }
           } catch {
             const match = clean.match(/https?:\/\/[^\s"]+#offer=[A-Za-z0-9_-]+/);
-            if (match && clean.includes('pairing_offer')) {
+            if (match && clean.includes("pairing_offer")) {
               try {
                 offerPayload = decodeOfferFromFragmentUrl(match[0]);
                 offerResolve?.();
@@ -462,8 +497,11 @@ export default async function globalSetup() {
       }
     });
 
-    daemonProcess.stderr?.on('data', (data: Buffer) => {
-      const lines = data.toString().split('\n').filter((line) => line.trim());
+    daemonProcess.stderr?.on("data", (data: Buffer) => {
+      const lines = data
+        .toString()
+        .split("\n")
+        .filter((line) => line.trim());
       for (const line of lines) {
         daemonLineBuffer.add(`[stderr] ${line}`);
         console.error(`[daemon] ${line}`);
@@ -473,12 +511,12 @@ export default async function globalSetup() {
     // Wait for both daemon and Metro to be ready
     await Promise.all([
       waitForServer(port, {
-        label: 'Paseo daemon',
+        label: "Paseo daemon",
         childProcess: daemonProcess,
         getRecentOutput: daemonLineBuffer.dump,
       }),
       waitForServer(metroPort, {
-        label: 'Metro web server',
+        label: "Metro web server",
         timeoutMs: 120000, // Metro can take longer to start
         childProcess: metroProcess,
         getRecentOutput: metroLineBuffer.dump,
@@ -489,11 +527,11 @@ export default async function globalSetup() {
     await Promise.race([
       offerPromise,
       new Promise((_, reject) =>
-        setTimeout(() => reject(new Error('Timed out waiting for pairing_offer log')), 15000)
+        setTimeout(() => reject(new Error("Timed out waiting for pairing_offer log")), 15000),
       ),
     ]);
     if (!offerPayload) {
-      throw new Error('pairing_offer was not parsed from daemon logs');
+      throw new Error("pairing_offer was not parsed from daemon logs");
     }
     const offer = offerPayload as OfferPayload;
 
@@ -502,11 +540,13 @@ export default async function globalSetup() {
     process.env.E2E_SERVER_ID = offer.serverId;
     process.env.E2E_RELAY_DAEMON_PUBLIC_KEY = offer.daemonPublicKeyB64;
     process.env.E2E_METRO_PORT = String(metroPort);
-    console.log(`[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, home: ${paseoHome}`);
+    console.log(
+      `[e2e] Test daemon started on port ${port}, Metro on port ${metroPort}, home: ${paseoHome}`,
+    );
 
     return async () => {
       await cleanup();
-      console.log('[e2e] Test daemon stopped');
+      console.log("[e2e] Test daemon stopped");
     };
   } catch (error) {
     await cleanup();

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

@@ -2,10 +2,8 @@ import { expect, type Page } from "@playwright/test";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { randomUUID } from "node:crypto";
-import {
-  buildHostWorkspaceAgentRoute,
-  buildHostWorkspaceRoute,
-} from "../../src/utils/host-routes";
+import { createNodeWebSocketFactory, type NodeWebSocketFactory } from "./node-ws-factory";
+import { buildHostWorkspaceRoute } from "../../src/utils/host-routes";
 
 const NEAR_BOTTOM_THRESHOLD_PX = 72;
 
@@ -37,10 +35,7 @@ export type DaemonClientInstance = {
     initialPrompt: string;
   }): Promise<{ id: string }>;
   sendAgentMessage(agentId: string, text: string): Promise<void>;
-  waitForFinish(
-    agentId: string,
-    timeout?: number
-  ): Promise<{ status: string }>;
+  waitForFinish(agentId: string, timeout?: number): Promise<{ status: string }>;
 };
 
 function getDaemonWsUrl(): string {
@@ -66,17 +61,17 @@ function buildReplyBlock(label: string, lineCount = 14): string {
   }).join("\n");
 }
 
-function buildProtocolMessage(label: string): string {
+function buildProtocolMessage(label: string, lineCount = 14): string {
   return [
     "For every message in this chat, reply with exactly the text after the final line `REPLY:`.",
     "Do not add extra words, bullets, markdown fences, or tool calls.",
     "REPLY:",
-    buildReplyBlock(label),
+    buildReplyBlock(label, lineCount),
   ].join("\n");
 }
 
-function buildReplyMessage(label: string): string {
-  return ["REPLY:", buildReplyBlock(label)].join("\n");
+function buildReplyMessage(label: string, lineCount = 14): string {
+  return ["REPLY:", buildReplyBlock(label, lineCount)].join("\n");
 }
 
 export function createReplyTurn(label: string): {
@@ -89,31 +84,36 @@ export function createReplyTurn(label: string): {
   };
 }
 
-async function loadDaemonClientConstructor(): Promise<new (config: {
+type DaemonClientConfig = {
   url: string;
   clientId: string;
   clientType: "cli";
-}) => DaemonClientInstance> {
-  const repoRoot = path.resolve(process.cwd(), "../..");
+  webSocketFactory?: NodeWebSocketFactory;
+};
+
+async function loadDaemonClientConstructor(): Promise<
+  new (
+    config: DaemonClientConfig,
+  ) => DaemonClientInstance
+> {
+  const repoRoot = path.resolve(__dirname, "../../../../");
   const moduleUrl = pathToFileURL(
-    path.join(repoRoot, "packages/server/dist/server/server/exports.js")
+    path.join(repoRoot, "packages/server/dist/server/server/exports.js"),
   ).href;
   const mod = (await import(moduleUrl)) as {
-    DaemonClient: new (config: {
-      url: string;
-      clientId: string;
-      clientType: "cli";
-    }) => DaemonClientInstance;
+    DaemonClient: new (config: DaemonClientConfig) => DaemonClientInstance;
   };
   return mod.DaemonClient;
 }
 
 export async function connectDaemonClient(): Promise<DaemonClientInstance> {
   const DaemonClient = await loadDaemonClientConstructor();
+  const webSocketFactory = createNodeWebSocketFactory();
   const client = new DaemonClient({
     url: getDaemonWsUrl(),
     clientId: `app-e2e-${randomUUID()}`,
     clientType: "cli",
+    webSocketFactory,
   });
   await client.connect();
   return client;
@@ -124,34 +124,36 @@ export async function seedBottomAnchorAgent(input: {
   cwd: string;
   title?: string;
   turnCount?: number;
+  lineCount?: number;
 }): Promise<SeededAgent> {
   const title = input.title ?? `bottom-anchor-${Date.now()}`;
   const turnCount = Math.max(3, input.turnCount ?? 5);
+  const lineCount = Math.max(14, input.lineCount ?? 14);
   const created = await input.client.createAgent({
     provider: "codex",
-    model: "gpt-5.1-codex-mini",
+    model: "gpt-5.4-mini",
     thinkingOptionId: "low",
     modeId: "full-access",
     cwd: input.cwd,
     title,
-    initialPrompt: buildProtocolMessage(`${title}-turn-00`),
+    initialPrompt: buildProtocolMessage(`${title}-turn-00`, lineCount),
   });
   const initialFinish = await input.client.waitForFinish(created.id, 120000);
   if (initialFinish.status !== "idle") {
     throw new Error(
-      `Expected seeded agent ${created.id} to become idle after initial prompt, got ${initialFinish.status}.`
+      `Expected seeded agent ${created.id} to become idle after initial prompt, got ${initialFinish.status}.`,
     );
   }
 
-  let expectedTailText = buildReplyBlock(`${title}-turn-00`);
+  let expectedTailText = buildReplyBlock(`${title}-turn-00`, lineCount);
   for (let index = 1; index < turnCount; index += 1) {
     const label = `${title}-turn-${index.toString().padStart(2, "0")}`;
-    expectedTailText = buildReplyBlock(label);
-    await input.client.sendAgentMessage(created.id, buildReplyMessage(label));
+    expectedTailText = buildReplyBlock(label, lineCount);
+    await input.client.sendAgentMessage(created.id, buildReplyMessage(label, lineCount));
     const finish = await input.client.waitForFinish(created.id, 120000);
     if (finish.status !== "idle") {
       throw new Error(
-        `Expected seeded agent ${created.id} to become idle after turn ${index}, got ${finish.status}.`
+        `Expected seeded agent ${created.id} to become idle after turn ${index}, got ${finish.status}.`,
       );
     }
   }
@@ -160,29 +162,37 @@ export async function seedBottomAnchorAgent(input: {
     id: created.id,
     title,
     expectedTailText,
-    url: buildHostWorkspaceAgentRoute(getServerId(), input.cwd, created.id),
+    url: `${buildHostWorkspaceRoute(getServerId(), input.cwd)}?open=${encodeURIComponent(`agent:${created.id}`)}`,
     workspaceUrl: buildHostWorkspaceRoute(getServerId(), input.cwd),
   };
 }
 
+function getVisibleChatScroll(page: Page) {
+  return page.locator('[data-testid="agent-chat-scroll"]:visible').first();
+}
+
 export async function readScrollMetrics(page: Page): Promise<ScrollMetrics> {
-  return page.getByTestId("agent-chat-scroll").evaluate((root: Element) => {
-    const rootElement = root as HTMLElement;
-    const candidates = [rootElement, ...Array.from(rootElement.querySelectorAll("*"))];
+  return getVisibleChatScroll(page).evaluate((root: Element) => {
+    const candidates = [root, ...Array.from(root.querySelectorAll("*"))]
+      .filter((element): element is HTMLElement => element instanceof HTMLElement)
+      .filter((element) => {
+        const tagName = element.tagName.toLowerCase();
+        const isEditable =
+          tagName === "textarea" ||
+          tagName === "input" ||
+          element.getAttribute("contenteditable") === "true";
+        return !isEditable && element.scrollHeight - element.clientHeight > 1;
+      });
     const scrollElement =
-      candidates.find(
-        (element) =>
-          element instanceof HTMLElement &&
-          element.scrollHeight - element.clientHeight > 1
-      ) ?? rootElement;
+      candidates.sort(
+        (left, right) =>
+          right.scrollHeight - right.clientHeight - (left.scrollHeight - left.clientHeight),
+      )[0] ?? (root as HTMLElement);
 
     const offsetY = Math.max(0, scrollElement.scrollTop);
     const contentHeight = Math.max(0, scrollElement.scrollHeight);
     const viewportHeight = Math.max(0, scrollElement.clientHeight);
-    const distanceFromBottom = Math.max(
-      0,
-      contentHeight - (offsetY + viewportHeight)
-    );
+    const distanceFromBottom = Math.max(0, contentHeight - (offsetY + viewportHeight));
 
     return {
       offsetY,
@@ -194,29 +204,33 @@ export async function readScrollMetrics(page: Page): Promise<ScrollMetrics> {
 }
 
 export async function scrollUpFromBottom(page: Page, pixels: number): Promise<void> {
-  await page.getByTestId("agent-chat-scroll").evaluate(
-    (root: Element, amount: number) => {
-      const rootElement = root as HTMLElement;
-      const candidates = [rootElement, ...Array.from(rootElement.querySelectorAll("*"))];
-      const scrollElement =
-        candidates.find(
-          (element) =>
-            element instanceof HTMLElement &&
-            element.scrollHeight - element.clientHeight > 1
-        ) ?? rootElement;
-
-      const bottomOffset = Math.max(
-        0,
-        scrollElement.scrollHeight - scrollElement.clientHeight
+  const scrollViewport = getVisibleChatScroll(page);
+  await expect(scrollViewport).toHaveCount(1, { timeout: 30000 });
+  let remaining = Math.max(0, pixels);
+  while (remaining > 0) {
+    const delta = Math.min(240, remaining);
+    await scrollViewport.evaluate((element: Element, step: number) => {
+      const scrollContainer = element as HTMLElement;
+      scrollContainer.dispatchEvent(
+        new WheelEvent("wheel", {
+          deltaY: -step,
+          bubbles: true,
+          cancelable: true,
+        }),
       );
-      scrollElement.scrollTop = Math.max(0, bottomOffset - amount);
-    },
-    pixels
-  );
+      scrollContainer.scrollTop = Math.max(0, scrollContainer.scrollTop - step);
+      scrollContainer.dispatchEvent(new Event("scroll", { bubbles: true }));
+    }, delta);
+    remaining -= delta;
+
+    if ((await readScrollMetrics(page)).distanceFromBottom > NEAR_BOTTOM_THRESHOLD_PX) {
+      return;
+    }
+  }
 }
 
 export async function waitForAgentReady(page: Page, expectedTailText?: string): Promise<void> {
-  await expect(page.getByTestId("agent-chat-scroll")).toBeVisible({ timeout: 60000 });
+  await expect(getVisibleChatScroll(page)).toBeVisible({ timeout: 60000 });
   await expect(page.getByRole("textbox", { name: "Message agent..." }).first()).toBeVisible({
     timeout: 60000,
   });
@@ -251,7 +265,7 @@ export async function expectDetachedFromBottom(page: Page): Promise<void> {
 
 export async function waitForContentGrowth(
   page: Page,
-  previousContentHeight: number
+  previousContentHeight: number,
 ): Promise<ScrollMetrics> {
   await expect
     .poll(async () => {
@@ -263,11 +277,9 @@ export async function waitForContentGrowth(
 }
 
 export async function getChatContainerKey(page: Page): Promise<string | null> {
-  return page
-    .getByTestId("agent-chat-scroll")
-    .evaluate((element) => {
-      const nativeId = (element as HTMLElement).id;
-      const prefix = "agent-chat-scroll-";
-      return nativeId.startsWith(prefix) ? nativeId.slice(prefix.length) : null;
-    });
+  return getVisibleChatScroll(page).evaluate((element) => {
+    const nativeId = (element as HTMLElement).id;
+    const prefix = "agent-chat-scroll-";
+    return nativeId.startsWith(prefix) ? nativeId.slice(prefix.length) : null;
+  });
 }

packages/app/e2e/helpers/app.ts

@@ -1,16 +1,19 @@
-import { expect, type Page } from '@playwright/test';
+import { expect, type Page } from "@playwright/test";
+import { buildCreateAgentPreferences, buildSeededHost } from "./daemon-registry";
 
 function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 function getE2EDaemonPort(): string {
   const port = process.env.E2E_DAEMON_PORT;
   if (!port) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from Playwright globalSetup).');
+    throw new Error("E2E_DAEMON_PORT is not set (expected from Playwright globalSetup).");
   }
-  if (port === '6767') {
-    throw new Error('E2E_DAEMON_PORT is 6767. Refusing to run e2e against the default local daemon.');
+  if (port === "6767") {
+    throw new Error(
+      "E2E_DAEMON_PORT is 6767. Refusing to run e2e against the default local daemon.",
+    );
   }
   return port;
 }
@@ -20,67 +23,58 @@ async function ensureE2EStorageSeeded(page: Page): Promise<void> {
   const expectedEndpoint = `127.0.0.1:${port}`;
   const expectedServerId = process.env.E2E_SERVER_ID;
   if (!expectedServerId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from Playwright globalSetup).');
+    throw new Error("E2E_SERVER_ID is not set (expected from Playwright globalSetup).");
   }
 
-  const needsReset = await page.evaluate(({ expectedEndpoint, expectedServerId }) => {
-    const raw = localStorage.getItem('@paseo:daemon-registry');
-    if (!raw) return true;
-    try {
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed) || parsed.length !== 1) return true;
-      const entry = parsed[0] as any;
-      if (entry?.serverId !== expectedServerId) return true;
-      const connections = entry?.connections;
-      if (!Array.isArray(connections)) return true;
-      if (connections.some((c: any) => c?.type === 'direct' && typeof c?.endpoint === 'string' && /:6767\b/.test(c.endpoint))) return true;
-      return !connections.some((c: any) => c?.type === 'direct' && c?.endpoint === expectedEndpoint);
-    } catch {
-      return true;
-    }
-  }, { expectedEndpoint, expectedServerId });
+  const needsReset = await page.evaluate(
+    ({ expectedEndpoint, expectedServerId }) => {
+      const raw = localStorage.getItem("@paseo:daemon-registry");
+      if (!raw) return true;
+      try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed) || parsed.length !== 1) return true;
+        const entry = parsed[0] as any;
+        if (entry?.serverId !== expectedServerId) return true;
+        const connections = entry?.connections;
+        if (!Array.isArray(connections)) return true;
+        if (
+          connections.some(
+            (c: any) =>
+              c?.type === "directTcp" &&
+              typeof c?.endpoint === "string" &&
+              /:6767\b/.test(c.endpoint),
+          )
+        )
+          return true;
+        return !connections.some(
+          (c: any) => c?.type === "directTcp" && c?.endpoint === expectedEndpoint,
+        );
+      } catch {
+        return true;
+      }
+    },
+    { expectedEndpoint, expectedServerId },
+  );
 
   if (!needsReset) {
     return;
   }
 
   const nowIso = new Date().toISOString();
+  const daemon = buildSeededHost({
+    serverId: expectedServerId,
+    endpoint: expectedEndpoint,
+    nowIso,
+  });
+  const preferences = buildCreateAgentPreferences(expectedServerId);
   await page.evaluate(
-    ({ expectedEndpoint, nowIso, expectedServerId }) => {
-      localStorage.setItem('@paseo:e2e', '1');
-      localStorage.setItem(
-        '@paseo:daemon-registry',
-        JSON.stringify([
-          {
-            serverId: expectedServerId,
-            label: 'localhost',
-            connections: [
-              {
-                id: `direct:${expectedEndpoint}`,
-                type: 'direct',
-                endpoint: expectedEndpoint,
-              },
-            ],
-            preferredConnectionId: `direct:${expectedEndpoint}`,
-            createdAt: nowIso,
-            updatedAt: nowIso,
-          },
-        ])
-      );
-      localStorage.setItem(
-        '@paseo:create-agent-preferences',
-        JSON.stringify({
-          serverId: expectedServerId,
-          provider: 'codex',
-          providerPreferences: {
-            claude: { model: 'haiku' },
-            codex: { model: 'gpt-5.1-codex-mini', thinkingOptionId: 'low' },
-          },
-        })
-      );
-      localStorage.removeItem('@paseo:settings');
+    ({ daemon, preferences }) => {
+      localStorage.setItem("@paseo:e2e", "1");
+      localStorage.setItem("@paseo:daemon-registry", JSON.stringify([daemon]));
+      localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
+      localStorage.removeItem("@paseo:settings");
     },
-    { expectedEndpoint, nowIso, expectedServerId }
+    { daemon, preferences },
   );
 
   await page.reload();
@@ -91,77 +85,116 @@ async function assertE2EUsesSeededTestDaemon(page: Page): Promise<void> {
   const expectedEndpoint = `127.0.0.1:${port}`;
   const expectedServerId = process.env.E2E_SERVER_ID;
   if (!expectedServerId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from Playwright globalSetup).');
+    throw new Error("E2E_SERVER_ID is not set (expected from Playwright globalSetup).");
   }
 
   const snapshot = await page.evaluate(() => {
-    const registryRaw = localStorage.getItem('@paseo:daemon-registry');
-    const prefsRaw = localStorage.getItem('@paseo:create-agent-preferences');
+    const registryRaw = localStorage.getItem("@paseo:daemon-registry");
+    const prefsRaw = localStorage.getItem("@paseo:create-agent-preferences");
     return { registryRaw, prefsRaw };
   });
 
   if (!snapshot.registryRaw) {
-    throw new Error('E2E expected @paseo:daemon-registry to be set before app load.');
+    throw new Error("E2E expected @paseo:daemon-registry to be set before app load.");
   }
 
   let registry: any;
   try {
     registry = JSON.parse(snapshot.registryRaw);
   } catch {
-    throw new Error('E2E expected @paseo:daemon-registry to be valid JSON.');
+    throw new Error("E2E expected @paseo:daemon-registry to be valid JSON.");
   }
 
   if (!Array.isArray(registry) || registry.length !== 1) {
     throw new Error(
-      `E2E expected @paseo:daemon-registry to contain exactly 1 daemon (got ${Array.isArray(registry) ? registry.length : 'non-array'}).`
+      `E2E expected @paseo:daemon-registry to contain exactly 1 daemon (got ${Array.isArray(registry) ? registry.length : "non-array"}).`,
     );
   }
 
   const daemon = registry[0];
-  if (typeof daemon?.serverId !== 'string' || daemon.serverId.length === 0) {
-    throw new Error(`E2E expected seeded daemon to have a string serverId (got ${String(daemon?.serverId)}).`);
+  if (typeof daemon?.serverId !== "string" || daemon.serverId.length === 0) {
+    throw new Error(
+      `E2E expected seeded daemon to have a string serverId (got ${String(daemon?.serverId)}).`,
+    );
   }
   if (daemon.serverId !== expectedServerId) {
-    throw new Error(`E2E expected seeded daemon serverId to be ${expectedServerId} (got ${daemon.serverId}).`);
+    throw new Error(
+      `E2E expected seeded daemon serverId to be ${expectedServerId} (got ${daemon.serverId}).`,
+    );
   }
 
   const connections: unknown = daemon?.connections;
   if (
     !Array.isArray(connections) ||
-    !connections.some((c: any) => c?.type === 'direct' && c?.endpoint === expectedEndpoint)
+    !connections.some((c: any) => c?.type === "directTcp" && c?.endpoint === expectedEndpoint)
   ) {
     throw new Error(
-      `E2E expected seeded daemon connections to include direct ${expectedEndpoint} (got ${JSON.stringify(connections)}).`
+      `E2E expected seeded daemon connections to include directTcp ${expectedEndpoint} (got ${JSON.stringify(connections)}).`,
     );
   }
-  if (Array.isArray(connections) && connections.some((c: any) => c?.type === 'direct' && typeof c?.endpoint === 'string' && /:6767\b/.test(c.endpoint))) {
-    throw new Error(`E2E detected a daemon endpoint pointing at :6767 (${JSON.stringify(connections)}).`);
+  if (
+    Array.isArray(connections) &&
+    connections.some(
+      (c: any) =>
+        c?.type === "directTcp" && typeof c?.endpoint === "string" && /:6767\b/.test(c.endpoint),
+    )
+  ) {
+    throw new Error(
+      `E2E detected a daemon endpoint pointing at :6767 (${JSON.stringify(connections)}).`,
+    );
   }
 
   if (!snapshot.prefsRaw) {
-    throw new Error('E2E expected @paseo:create-agent-preferences to be set before app load.');
+    throw new Error("E2E expected @paseo:create-agent-preferences to be set before app load.");
   }
   try {
     const prefs = JSON.parse(snapshot.prefsRaw) as any;
     if (prefs?.serverId !== daemon.serverId) {
       throw new Error(
-        `E2E expected create-agent-preferences.serverId to match seeded daemon serverId (${daemon.serverId}) (got ${String(prefs?.serverId)}).`
+        `E2E expected create-agent-preferences.serverId to match seeded daemon serverId (${daemon.serverId}) (got ${String(prefs?.serverId)}).`,
       );
     }
   } catch (error) {
     if (error instanceof Error) throw error;
-    throw new Error('E2E expected @paseo:create-agent-preferences to be valid JSON.');
+    throw new Error("E2E expected @paseo:create-agent-preferences to be valid JSON.");
   }
 }
 
-export const gotoHome = async (page: Page) => {
-  await page.goto('/');
+export const gotoAppShell = async (page: Page) => {
+  await page.goto("/");
   await ensureE2EStorageSeeded(page);
-  await expect(page.getByText('New agent', { exact: true }).first()).toBeVisible();
-  const composer = page.getByRole('textbox', { name: 'Message agent...' });
-  if (!(await composer.first().isVisible().catch(() => false))) {
-    const newAgentButton = page.getByText('New agent', { exact: true }).first();
-    await newAgentButton.click();
+};
+
+export const gotoHome = async (page: Page) => {
+  await gotoAppShell(page);
+  const composer = page.getByRole("textbox", { name: "Message agent..." });
+  if (
+    !(await composer
+      .first()
+      .isVisible()
+      .catch(() => false))
+  ) {
+    const addProjectCta = page.getByText("Add a project", { exact: true }).first();
+    const addProjectSidebar = page.getByText("Add project", { exact: true }).first();
+    const newAgentButton = page.getByText("New agent", { exact: true }).first();
+
+    await expect
+      .poll(
+        async () =>
+          (await addProjectCta.isVisible().catch(() => false)) ||
+          (await addProjectSidebar.isVisible().catch(() => false)) ||
+          (await newAgentButton.isVisible().catch(() => false)),
+        { timeout: 10000 },
+      )
+      .toBe(true);
+
+    if (await addProjectCta.isVisible().catch(() => false)) {
+      await addProjectCta.click();
+    } else if (await addProjectSidebar.isVisible().catch(() => false)) {
+      await addProjectSidebar.click();
+    } else {
+      await newAgentButton.click();
+    }
   }
   await expect(composer.first()).toBeVisible({ timeout: 30000 });
 };
@@ -169,7 +202,7 @@ export const gotoHome = async (page: Page) => {
 export const openSettings = async (page: Page) => {
   const serverId = process.env.E2E_SERVER_ID;
   if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from Playwright globalSetup).');
+    throw new Error("E2E_SERVER_ID is not set (expected from Playwright globalSetup).");
   }
 
   // Navigate through the real app control so route changes stay aligned with UI behavior.
@@ -185,23 +218,19 @@ export const setWorkingDirectory = async (page: Page, directory: string) => {
     .first();
   await expect(workingDirectorySelect).toBeVisible({ timeout: 30000 });
 
-  const legacyInput = page.getByRole('textbox', { name: '/path/to/project' }).first();
-  const directorySearchInput = page.getByRole('textbox', { name: /search directories/i }).first();
-  const worktreePicker = page.getByTestId('worktree-attach-picker');
-  const worktreeSheetTitle = page.getByText('Select worktree', { exact: true }).first();
+  const legacyInput = page.getByRole("textbox", { name: "/path/to/project" }).first();
+  const directorySearchInput = page.getByRole("textbox", { name: /search directories/i }).first();
+  const worktreePicker = page.getByTestId("worktree-attach-picker");
+  const worktreeSheetTitle = page.getByText("Select worktree", { exact: true }).first();
   const closeBottomSheet = async () => {
-    const bottomSheetBackdrop = page
-      .getByRole('button', { name: 'Bottom sheet backdrop' })
-      .first();
-    const bottomSheetHandle = page
-      .getByRole('slider', { name: 'Bottom sheet handle' })
-      .first();
+    const bottomSheetBackdrop = page.getByRole("button", { name: "Bottom sheet backdrop" }).first();
+    const bottomSheetHandle = page.getByRole("slider", { name: "Bottom sheet handle" }).first();
     for (let attempt = 0; attempt < 3; attempt += 1) {
       if (!(await bottomSheetBackdrop.isVisible())) {
         return;
       }
       await bottomSheetBackdrop.click({ force: true });
-      await page.keyboard.press('Escape').catch(() => undefined);
+      await page.keyboard.press("Escape").catch(() => undefined);
       await page.waitForTimeout(200);
     }
     if (await bottomSheetBackdrop.isVisible()) {
@@ -221,7 +250,7 @@ export const setWorkingDirectory = async (page: Page, directory: string) => {
     if (!(await worktreeSheetTitle.isVisible()) && !(await worktreePicker.isVisible())) {
       return;
     }
-    const attachToggle = page.getByTestId('worktree-attach-toggle');
+    const attachToggle = page.getByTestId("worktree-attach-toggle");
     if (await attachToggle.isVisible()) {
       await attachToggle.click({ force: true });
       await page.waitForTimeout(200);
@@ -242,26 +271,23 @@ export const setWorkingDirectory = async (page: Page, directory: string) => {
       await closeBottomSheet();
       await workingDirectorySelect.click({ force: true });
     }
-    await expect
-      .poll(async () => pickerInputVisible(), { timeout: 10000 })
-      .toBe(true);
+    await expect.poll(async () => pickerInputVisible(), { timeout: 10000 }).toBe(true);
   }
 
-  const trimmedDirectory = directory.replace(/\/+$/, '');
-  const activeInput =
-    (await directorySearchInput.isVisible().catch(() => false))
-      ? directorySearchInput
-      : legacyInput;
+  const trimmedDirectory = directory.replace(/\/+$/, "");
+  const activeInput = (await directorySearchInput.isVisible().catch(() => false))
+    ? directorySearchInput
+    : legacyInput;
 
   await activeInput.fill(trimmedDirectory);
 
   if (activeInput === directorySearchInput) {
     // Combobox custom rows can be either plain path labels or prefixed labels.
     const plainOption = page
-      .getByText(new RegExp(`^${escapeRegex(trimmedDirectory)}$`, 'i'))
+      .getByText(new RegExp(`^${escapeRegex(trimmedDirectory)}$`, "i"))
       .first();
     const prefixedUseOption = page
-      .getByText(new RegExp(`^Use "${escapeRegex(trimmedDirectory)}"$`, 'i'))
+      .getByText(new RegExp(`^Use "${escapeRegex(trimmedDirectory)}"$`, "i"))
       .first();
 
     if (await plainOption.isVisible().catch(() => false)) {
@@ -270,33 +296,38 @@ export const setWorkingDirectory = async (page: Page, directory: string) => {
       await prefixedUseOption.click({ force: true });
     } else {
       // Fallback: accept highlighted option (directory suggestion).
-      await activeInput.press('Enter');
+      await activeInput.press("Enter");
     }
   } else {
     // Legacy path picker fallback.
-    await activeInput.press('Enter');
+    await activeInput.press("Enter");
   }
 
   // Wait for picker to close.
   await expect(activeInput).not.toBeVisible({ timeout: 10000 });
 
   const directoryCandidates = new Set<string>([trimmedDirectory]);
-  if (trimmedDirectory.startsWith('/var/')) {
+  if (trimmedDirectory.startsWith("/var/")) {
     directoryCandidates.add(`/private${trimmedDirectory}`);
   }
-  if (trimmedDirectory.startsWith('/private/var/')) {
-    directoryCandidates.add(trimmedDirectory.replace(/^\/private/, ''));
+  if (trimmedDirectory.startsWith("/private/var/")) {
+    directoryCandidates.add(trimmedDirectory.replace(/^\/private/, ""));
   }
-  const basename = trimmedDirectory.split('/').filter(Boolean).pop() ?? trimmedDirectory;
+  const basename = trimmedDirectory.split("/").filter(Boolean).pop() ?? trimmedDirectory;
 
-  await expect.poll(async () => {
-    const text = await workingDirectorySelect.innerText().catch(() => '');
-    if (text.includes(basename)) return true;
-    for (const candidate of directoryCandidates) {
-      if (text.includes(candidate)) return true;
-    }
-    return false;
-  }, { timeout: 30000 }).toBe(true);
+  await expect
+    .poll(
+      async () => {
+        const text = await workingDirectorySelect.innerText().catch(() => "");
+        if (text.includes(basename)) return true;
+        for (const candidate of directoryCandidates) {
+          if (text.includes(candidate)) return true;
+        }
+        return false;
+      },
+      { timeout: 30000 },
+    )
+    .toBe(true);
 };
 
 export const ensureHostSelected = async (page: Page) => {
@@ -314,19 +345,21 @@ export const ensureHostSelected = async (page: Page) => {
     }
 
     const fix = await page.evaluate(() => {
-      const registryRaw = localStorage.getItem('@paseo:daemon-registry');
-      const prefsRaw = localStorage.getItem('@paseo:create-agent-preferences');
-      if (!registryRaw || !prefsRaw) return { ok: false, reason: 'missing storage' } as const;
+      const registryRaw = localStorage.getItem("@paseo:daemon-registry");
+      const prefsRaw = localStorage.getItem("@paseo:create-agent-preferences");
+      if (!registryRaw || !prefsRaw) return { ok: false, reason: "missing storage" } as const;
       const registry = JSON.parse(registryRaw) as any[];
       const prefs = JSON.parse(prefsRaw) as any;
-      if (!Array.isArray(registry) || registry.length !== 1) return { ok: false, reason: 'registry shape' } as const;
+      if (!Array.isArray(registry) || registry.length !== 1)
+        return { ok: false, reason: "registry shape" } as const;
       const serverId = registry[0]?.serverId;
-      if (typeof serverId !== 'string' || serverId.length === 0) return { ok: false, reason: 'missing serverId' } as const;
+      if (typeof serverId !== "string" || serverId.length === 0)
+        return { ok: false, reason: "missing serverId" } as const;
       prefs.serverId = serverId;
-      localStorage.setItem('@paseo:create-agent-preferences', JSON.stringify(prefs));
+      localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(prefs));
       // Prevent the fixture's init-script from overwriting the corrected prefs on reload.
-      const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-      localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
+      const nonce = localStorage.getItem("@paseo:e2e-seed-nonce") ?? "1";
+      localStorage.setItem("@paseo:e2e-disable-default-seed-once", nonce);
       return { ok: true } as const;
     });
 
@@ -338,20 +371,22 @@ export const ensureHostSelected = async (page: Page) => {
     await assertE2EUsesSeededTestDaemon(page);
   }
 
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
+  const input = page.getByRole("textbox", { name: "Message agent..." });
   await expect(input).toBeVisible();
 
   if (await input.isEditable()) {
     return;
   }
 
-  const selectHostLabel = page.getByText('Select host', { exact: true });
+  const selectHostLabel = page.getByText("Select host", { exact: true });
   if (await selectHostLabel.isVisible()) {
     await selectHostLabel.click();
 
     // E2E safety: we enforce a single seeded daemon, so the option should be unambiguous.
-    const localhostOption = page.getByText('localhost', { exact: true }).first();
-    const daemonIdOption = page.getByText(process.env.E2E_SERVER_ID ?? 'srv_e2e_test_daemon', { exact: true }).first();
+    const localhostOption = page.getByText("localhost", { exact: true }).first();
+    const daemonIdOption = page
+      .getByText(process.env.E2E_SERVER_ID ?? "srv_e2e_test_daemon", { exact: true })
+      .first();
 
     if (await localhostOption.isVisible()) {
       await localhostOption.click();
@@ -365,11 +400,11 @@ export const ensureHostSelected = async (page: Page) => {
 };
 
 export const createAgent = async (page: Page, message: string) => {
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
+  const input = page.getByRole("textbox", { name: "Message agent..." });
   await expect(input).toBeEditable();
   await preferFastThinkingOption(page);
   await input.fill(message);
-  await input.press('Enter');
+  await input.press("Enter");
 
   // The composer may remain on the draft screen briefly while the initial run starts,
   // so assert the user-visible result instead of forcing one route shape here.
@@ -381,21 +416,23 @@ export const createAgent = async (page: Page, message: string) => {
 
 async function preferFastThinkingOption(page: Page): Promise<void> {
   const providerTrigger = page
-    .locator('[data-testid="agent-provider-selector"]:visible, [data-testid="draft-provider-select"]:visible')
+    .locator(
+      '[data-testid="agent-provider-selector"]:visible, [data-testid="draft-provider-select"]:visible',
+    )
     .first();
   if (await providerTrigger.isVisible().catch(() => false)) {
-    const providerText = ((await providerTrigger.innerText().catch(() => '')) ?? '').trim();
+    const providerText = ((await providerTrigger.innerText().catch(() => "")) ?? "").trim();
     if (!/codex/i.test(providerText)) {
       return;
     }
   }
 
-  const thinkingTrigger = page.getByTestId('agent-thinking-selector').first();
+  const thinkingTrigger = page.getByTestId("agent-thinking-selector").first();
   if (!(await thinkingTrigger.isVisible().catch(() => false))) {
     return;
   }
 
-  const currentThinkingLabel = ((await thinkingTrigger.innerText().catch(() => '')) ?? '')
+  const currentThinkingLabel = ((await thinkingTrigger.innerText().catch(() => "")) ?? "")
     .trim()
     .toLowerCase();
   if (/\b(low|minimal|off)\b/.test(currentThinkingLabel)) {
@@ -403,16 +440,16 @@ async function preferFastThinkingOption(page: Page): Promise<void> {
   }
 
   await thinkingTrigger.click();
-  const menu = page.getByTestId('agent-thinking-menu').first();
+  const menu = page.getByTestId("agent-thinking-menu").first();
   if (!(await menu.isVisible().catch(() => false))) {
     return;
   }
 
-  const preferredLabels = ['low', 'minimal', 'off', 'medium'];
+  const preferredLabels = ["low", "minimal", "off", "medium"];
   let selected = false;
   for (const label of preferredLabels) {
     const option = menu
-      .getByRole('button', { name: new RegExp(`^${escapeRegex(label)}$`, 'i') })
+      .getByRole("button", { name: new RegExp(`^${escapeRegex(label)}$`, "i") })
       .first();
     if (await option.isVisible().catch(() => false)) {
       await option.click({ force: true });
@@ -422,11 +459,11 @@ async function preferFastThinkingOption(page: Page): Promise<void> {
   }
 
   if (!selected) {
-    const options = menu.getByRole('button');
+    const options = menu.getByRole("button");
     const count = await options.count();
     for (let index = 0; index < count; index += 1) {
       const option = options.nth(index);
-      const label = ((await option.innerText().catch(() => '')) ?? '').trim();
+      const label = ((await option.innerText().catch(() => "")) ?? "").trim();
       if (!label) {
         continue;
       }
@@ -440,7 +477,7 @@ async function preferFastThinkingOption(page: Page): Promise<void> {
   }
 
   if (!selected) {
-    await page.keyboard.press('Escape').catch(() => undefined);
+    await page.keyboard.press("Escape").catch(() => undefined);
     return;
   }
 
@@ -458,15 +495,17 @@ export interface AgentConfig {
 export const selectProvider = async (page: Page, provider: string) => {
   const normalizedProvider = provider.trim();
   if (!normalizedProvider) {
-    throw new Error('Provider must be a non-empty string.');
+    throw new Error("Provider must be a non-empty string.");
   }
 
   const providerTrigger = page
-    .locator('[data-testid="agent-provider-selector"]:visible, [data-testid="draft-provider-select"]:visible')
+    .locator(
+      '[data-testid="agent-provider-selector"]:visible, [data-testid="draft-provider-select"]:visible',
+    )
     .first();
   if (
     await providerTrigger
-      .getByText(new RegExp(`^${escapeRegex(normalizedProvider)}$`, 'i'))
+      .getByText(new RegExp(`^${escapeRegex(normalizedProvider)}$`, "i"))
       .first()
       .isVisible()
       .catch(() => false)
@@ -477,20 +516,18 @@ export const selectProvider = async (page: Page, provider: string) => {
   if (await providerTrigger.isVisible().catch(() => false)) {
     await providerTrigger.click();
   } else {
-    const providerLabel = page.getByText('PROVIDER', { exact: true }).first();
+    const providerLabel = page.getByText("PROVIDER", { exact: true }).first();
     await expect(providerLabel).toBeVisible();
     await providerLabel.click();
   }
 
-  const dialog = page.getByRole('dialog').last();
-  const searchInput = dialog.getByRole('textbox', { name: /search provider/i }).first();
+  const dialog = page.getByRole("dialog").last();
+  const searchInput = dialog.getByRole("textbox", { name: /search provider/i }).first();
   if (await searchInput.isVisible().catch(() => false)) {
     await searchInput.fill(normalizedProvider);
   }
 
-  const option = dialog
-    .getByText(new RegExp(`^${escapeRegex(normalizedProvider)}$`, 'i'))
-    .first();
+  const option = dialog.getByText(new RegExp(`^${escapeRegex(normalizedProvider)}$`, "i")).first();
   await expect(option).toBeVisible();
   await option.click();
 };
@@ -498,15 +535,17 @@ export const selectProvider = async (page: Page, provider: string) => {
 export const selectModel = async (page: Page, model: string) => {
   const normalizedModel = model.trim();
   if (!normalizedModel) {
-    throw new Error('Model must be a non-empty string.');
+    throw new Error("Model must be a non-empty string.");
   }
 
   const modelTrigger = page
-    .locator('[data-testid="agent-model-selector"]:visible, [data-testid="draft-model-select"]:visible')
+    .locator(
+      '[data-testid="agent-model-selector"]:visible, [data-testid="draft-model-select"]:visible',
+    )
     .first();
   if (
     await modelTrigger
-      .getByText(new RegExp(`^${escapeRegex(normalizedModel)}$`, 'i'))
+      .getByText(new RegExp(`^${escapeRegex(normalizedModel)}$`, "i"))
       .first()
       .isVisible()
       .catch(() => false)
@@ -517,21 +556,21 @@ export const selectModel = async (page: Page, model: string) => {
   if (await modelTrigger.isVisible().catch(() => false)) {
     await modelTrigger.click();
   } else {
-    const modelLabel = page.getByText('MODEL', { exact: true }).first();
+    const modelLabel = page.getByText("MODEL", { exact: true }).first();
     await expect(modelLabel).toBeVisible();
     await modelLabel.click();
   }
 
   // Wait for the model dropdown to open
-  const searchInput = page.getByRole('textbox', { name: /search model/i });
+  const searchInput = page.getByRole("textbox", { name: /search model/i });
   await expect(searchInput).toBeVisible({ timeout: 10000 });
 
   // Type to search/filter models
   await searchInput.fill(normalizedModel);
 
-  const dialog = page.getByRole('dialog');
+  const dialog = page.getByRole("dialog");
   const exactOption = dialog
-    .getByText(new RegExp(`^${escapeRegex(normalizedModel)}$`, 'i'))
+    .getByText(new RegExp(`^${escapeRegex(normalizedModel)}$`, "i"))
     .first();
   const exactVisible = await exactOption.isVisible().catch(() => false);
   if (exactVisible) {
@@ -539,39 +578,39 @@ export const selectModel = async (page: Page, model: string) => {
   } else {
     // Modern labels include version suffixes (for example "Haiku 4.5"), so
     // select the first filtered result using keyboard confirm.
-    await searchInput.press('Enter');
+    await searchInput.press("Enter");
   }
 
   // Wait for dropdown to close
   if (await searchInput.isVisible().catch(() => false)) {
-    await page.keyboard.press('Escape').catch(() => undefined);
+    await page.keyboard.press("Escape").catch(() => undefined);
   }
   await expect(searchInput).not.toBeVisible({ timeout: 5000 });
 };
 
 export const selectMode = async (page: Page, mode: string) => {
   const modeTrigger = page
-    .locator('[data-testid="agent-mode-selector"]:visible, [data-testid="draft-mode-select"]:visible')
+    .locator(
+      '[data-testid="agent-mode-selector"]:visible, [data-testid="draft-mode-select"]:visible',
+    )
     .first();
   if (await modeTrigger.isVisible().catch(() => false)) {
     await modeTrigger.click();
   } else {
-    const modeLabel = page.getByText('MODE', { exact: true }).first();
+    const modeLabel = page.getByText("MODE", { exact: true }).first();
     await expect(modeLabel).toBeVisible();
     await modeLabel.click();
   }
 
   // Wait for the mode dropdown to open
-  const searchInput = page.getByRole('textbox', { name: /search mode/i });
+  const searchInput = page.getByRole("textbox", { name: /search mode/i });
   await expect(searchInput).toBeVisible({ timeout: 10000 });
 
   // Type to filter modes
   await searchInput.fill(mode);
 
-  const dialog = page.getByRole('dialog');
-  const option = dialog
-    .getByText(new RegExp(`^${escapeRegex(mode)}$`, 'i'))
-    .first();
+  const dialog = page.getByRole("dialog");
+  const option = dialog.getByText(new RegExp(`^${escapeRegex(mode)}$`, "i")).first();
   await expect(option).toBeVisible();
   await option.click({ force: true });
 
@@ -601,7 +640,7 @@ export const createAgentWithConfig = async (page: Page, config: AgentConfig) =>
 
 export const createAgentInRepo = async (
   page: Page,
-  config: Pick<AgentConfig, 'directory' | 'prompt'>
+  config: Pick<AgentConfig, "directory" | "prompt">,
 ) => {
   await gotoHome(page);
   await ensureHostSelected(page);
@@ -610,25 +649,25 @@ export const createAgentInRepo = async (
 };
 
 export const waitForPermissionPrompt = async (page: Page, timeout = 30000) => {
-  const promptText = page.getByTestId('permission-request-question').first();
+  const promptText = page.getByTestId("permission-request-question").first();
   await expect(promptText).toBeVisible({ timeout });
 };
 
 export const allowPermission = async (page: Page) => {
-  const acceptButton = page.getByTestId('permission-request-accept').first();
+  const acceptButton = page.getByTestId("permission-request-accept").first();
   await expect(acceptButton).toBeVisible({ timeout: 5000 });
   await acceptButton.click();
 };
 
 export const denyPermission = async (page: Page) => {
-  const denyButton = page.getByTestId('permission-request-deny').first();
+  const denyButton = page.getByTestId("permission-request-deny").first();
   await expect(denyButton).toBeVisible({ timeout: 5000 });
   await denyButton.click();
 };
 
 export async function waitForAgentFinishUI(page: Page, timeout = 30000) {
   // Wait for the stop button to disappear
-  const stopButton = page.getByRole('button', { name: /stop|cancel/i });
+  const stopButton = page.getByRole("button", { name: /stop|cancel/i });
 
   // First, let's debug what's happening - wait a bit to see the state
   await page.waitForTimeout(2000);
@@ -645,9 +684,11 @@ export async function waitForAgentFinishUI(page: Page, timeout = 30000) {
     const toolCallResult = page.getByText(/permission.*denied|denied|blocked/i);
 
     // Wait for the tool call result to appear
-    await expect(toolCallResult).toBeVisible({ timeout: 10000 }).catch(() => {
-      // If no specific message, just wait for the button to disappear
-    });
+    await expect(toolCallResult)
+      .toBeVisible({ timeout: 10000 })
+      .catch(() => {
+        // If no specific message, just wait for the button to disappear
+      });
 
     // Now wait for the stop button to disappear
     await expect(stopButton).not.toBeVisible({ timeout });

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

@@ -0,0 +1,266 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { expect, type Page } from "@playwright/test";
+import { buildCreateAgentPreferences, buildSeededHost } from "./daemon-registry";
+import { createNodeWebSocketFactory, type NodeWebSocketFactory } from "./node-ws-factory";
+import { waitForWorkspaceTabsVisible } from "./workspace-tabs";
+import {
+  buildHostAgentDetailRoute,
+  buildHostSessionsRoute,
+  buildHostWorkspaceRoute,
+} from "@/utils/host-routes";
+
+export type ArchiveTabAgent = {
+  id: string;
+  title: string;
+  cwd: string;
+};
+
+type ArchiveTabDaemonClient = {
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  createAgent(options: {
+    provider: string;
+    model: string;
+    thinkingOptionId?: string;
+    modeId: string;
+    cwd: string;
+    title: string;
+    initialPrompt: string;
+  }): Promise<{ id: string }>;
+  archiveAgent(agentId: string): Promise<{ archivedAt: string }>;
+  waitForFinish(agentId: string, timeout?: number): Promise<{ status: string }>;
+};
+
+function getDaemonPort(): string {
+  const daemonPort = process.env.E2E_DAEMON_PORT;
+  if (!daemonPort) {
+    throw new Error("E2E_DAEMON_PORT is not set.");
+  }
+  if (daemonPort === "6767") {
+    throw new Error("E2E_DAEMON_PORT must not point at the developer daemon.");
+  }
+  return daemonPort;
+}
+
+function getServerId(): string {
+  const serverId = process.env.E2E_SERVER_ID;
+  if (!serverId) {
+    throw new Error("E2E_SERVER_ID is not set.");
+  }
+  return serverId;
+}
+
+function getDaemonWsUrl(): string {
+  return `ws://127.0.0.1:${getDaemonPort()}/ws`;
+}
+
+function buildSeededStoragePayload() {
+  const nowIso = new Date().toISOString();
+  return {
+    daemon: buildSeededHost({
+      serverId: getServerId(),
+      endpoint: `127.0.0.1:${getDaemonPort()}`,
+      nowIso,
+    }),
+    preferences: buildCreateAgentPreferences(getServerId()),
+  };
+}
+
+type ArchiveTabDaemonClientConfig = {
+  url: string;
+  clientId: string;
+  clientType: "cli";
+  webSocketFactory?: NodeWebSocketFactory;
+};
+
+async function loadDaemonClientConstructor(): Promise<
+  new (
+    config: ArchiveTabDaemonClientConfig,
+  ) => ArchiveTabDaemonClient
+> {
+  const repoRoot = path.resolve(__dirname, "../../../../");
+  const moduleUrl = pathToFileURL(
+    path.join(repoRoot, "packages/server/dist/server/server/exports.js"),
+  ).href;
+  const mod = (await import(moduleUrl)) as {
+    DaemonClient: new (config: ArchiveTabDaemonClientConfig) => ArchiveTabDaemonClient;
+  };
+  return mod.DaemonClient;
+}
+
+export async function connectArchiveTabDaemonClient(): Promise<ArchiveTabDaemonClient> {
+  const DaemonClient = await loadDaemonClientConstructor();
+  const webSocketFactory = createNodeWebSocketFactory();
+  const client = new DaemonClient({
+    url: getDaemonWsUrl(),
+    clientId: `app-e2e-archive-tab-${randomUUID()}`,
+    clientType: "cli",
+    webSocketFactory,
+  });
+  await client.connect();
+  return client;
+}
+
+export async function createIdleAgent(
+  client: ArchiveTabDaemonClient,
+  input: { cwd: string; title: string },
+): Promise<ArchiveTabAgent> {
+  const created = await client.createAgent({
+    provider: "opencode",
+    model: "opencode/gpt-5-nano",
+    modeId: "default",
+    cwd: input.cwd,
+    title: input.title,
+    initialPrompt: "Reply with exactly READY.",
+  });
+  const finished = await client.waitForFinish(created.id, 120_000);
+  if (finished.status !== "idle") {
+    throw new Error(
+      `Expected agent ${created.id} to become idle, got ${finished.status}. Error: ${JSON.stringify((finished as Record<string, unknown>).error ?? "unknown")}`,
+    );
+  }
+  return {
+    id: created.id,
+    title: input.title,
+    cwd: input.cwd,
+  };
+}
+
+export async function archiveAgentFromDaemon(
+  client: ArchiveTabDaemonClient,
+  agentId: string,
+): Promise<void> {
+  await client.archiveAgent(agentId);
+}
+
+export async function primeAdditionalPage(page: Page): Promise<void> {
+  const seedNonce = randomUUID();
+  const { daemon, preferences } = buildSeededStoragePayload();
+
+  await page.route(/:(6767)\b/, (route) => route.abort());
+  await page.routeWebSocket(/:(6767)\b/, async (ws) => {
+    await ws.close({ code: 1008, reason: "Blocked connection to localhost:6767 during e2e." });
+  });
+  await page.addInitScript(
+    ({ daemon, preferences, seedNonce }) => {
+      const disableOnceKey = "@paseo:e2e-disable-default-seed-once";
+      const disableValue = localStorage.getItem(disableOnceKey);
+      if (disableValue) {
+        localStorage.removeItem(disableOnceKey);
+        if (disableValue === seedNonce) {
+          return;
+        }
+      }
+
+      localStorage.setItem("@paseo:e2e", "1");
+      localStorage.setItem("@paseo:e2e-seed-nonce", seedNonce);
+      localStorage.setItem("@paseo:daemon-registry", JSON.stringify([daemon]));
+      localStorage.removeItem("@paseo:settings");
+      localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
+    },
+    { daemon, preferences, seedNonce },
+  );
+  await page.goto("/");
+}
+
+export async function resetSeededPageState(page: Page): Promise<void> {
+  const { daemon, preferences } = buildSeededStoragePayload();
+  await page.goto("/");
+  await page.evaluate(
+    ({ daemon, preferences }) => {
+      localStorage.clear();
+      localStorage.setItem("@paseo:e2e", "1");
+      localStorage.setItem("@paseo:daemon-registry", JSON.stringify([daemon]));
+      localStorage.setItem("@paseo:create-agent-preferences", JSON.stringify(preferences));
+      localStorage.removeItem("@paseo:settings");
+    },
+    { daemon, preferences },
+  );
+  await page.goto("/");
+}
+
+export async function openWorkspaceWithAgents(
+  page: Page,
+  agents: [ArchiveTabAgent, ArchiveTabAgent],
+): Promise<void> {
+  const serverId = getServerId();
+  for (const agent of agents) {
+    await page.goto(buildHostAgentDetailRoute(serverId, agent.id, agent.cwd));
+    await waitForWorkspaceTabsVisible(page);
+    await expectWorkspaceTabVisible(page, agent.id);
+  }
+}
+
+export async function expectWorkspaceTabVisible(page: Page, agentId: string): Promise<void> {
+  await expect(page.getByTestId(`workspace-tab-agent_${agentId}`).first()).toBeVisible({
+    timeout: 30_000,
+  });
+}
+
+export async function expectWorkspaceTabHidden(page: Page, agentId: string): Promise<void> {
+  await expect(page.getByTestId(`workspace-tab-agent_${agentId}`)).toHaveCount(0, {
+    timeout: 30_000,
+  });
+}
+
+export async function expectWorkspaceArchiveOutcome(
+  page: Page,
+  input: { archivedAgentId: string; survivingAgentId: string },
+): Promise<void> {
+  await expectWorkspaceTabHidden(page, input.archivedAgentId);
+  await expectWorkspaceTabVisible(page, input.survivingAgentId);
+}
+
+export async function reloadWorkspace(page: Page, workspaceId: string): Promise<void> {
+  const serverId = getServerId();
+  await page.goto(buildHostWorkspaceRoute(serverId, workspaceId));
+  await waitForWorkspaceTabsVisible(page);
+}
+
+export async function openSessions(page: Page): Promise<void> {
+  const sessionsButton = page.getByTestId("sidebar-sessions");
+  await expect(sessionsButton).toBeVisible({ timeout: 30_000 });
+  await sessionsButton.click();
+  await expect(page).toHaveURL(new RegExp(`${buildHostSessionsRoute(getServerId())}$`), {
+    timeout: 30_000,
+  });
+  await expect(page.getByText("Sessions", { exact: true }).last()).toBeVisible({
+    timeout: 30_000,
+  });
+}
+
+function getSessionRowByTitle(page: Page, title: string) {
+  return page.locator('[data-testid^="agent-row-"]').filter({ hasText: title }).first();
+}
+
+export async function expectSessionRowVisible(page: Page, title: string): Promise<void> {
+  await expect(getSessionRowByTitle(page, title)).toBeVisible({ timeout: 30_000 });
+}
+
+export async function expectSessionRowArchived(page: Page, title: string): Promise<void> {
+  await expect(getSessionRowByTitle(page, title)).toContainText("Archived", { timeout: 30_000 });
+}
+
+export async function archiveAgentFromSessions(
+  page: Page,
+  input: { agentId: string; title: string },
+): Promise<void> {
+  const row = getSessionRowByTitle(page, input.title);
+  await expect(row).toBeVisible({ timeout: 30_000 });
+  const box = await row.boundingBox();
+  if (!box) {
+    throw new Error(`Could not read bounding box for session row ${input.agentId}.`);
+  }
+
+  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
+  await page.mouse.down();
+  await page.waitForTimeout(900);
+  await page.mouse.up();
+
+  const archiveButton = page.getByTestId("agent-action-archive").first();
+  await expect(archiveButton).toBeVisible({ timeout: 10_000 });
+  await archiveButton.click();
+  await expectSessionRowArchived(page, input.title);
+}

packages/app/e2e/helpers/daemon-registry.ts

@@ -0,0 +1,39 @@
+export const TEST_HOST_LABEL = "localhost";
+
+export const TEST_PROVIDER_PREFERENCES = {
+  claude: { model: "haiku" },
+  codex: { model: "gpt-5.4-mini", thinkingOptionId: "low" },
+} as const;
+
+export function buildDirectTcpConnection(endpoint: string) {
+  return {
+    id: `direct:${endpoint}`,
+    type: "directTcp" as const,
+    endpoint,
+  };
+}
+
+export function buildSeededHost(input: {
+  serverId: string;
+  endpoint: string;
+  label?: string;
+  nowIso: string;
+}) {
+  const connection = buildDirectTcpConnection(input.endpoint);
+  return {
+    serverId: input.serverId,
+    label: input.label ?? TEST_HOST_LABEL,
+    connections: [connection],
+    preferredConnectionId: connection.id,
+    createdAt: input.nowIso,
+    updatedAt: input.nowIso,
+  };
+}
+
+export function buildCreateAgentPreferences(serverId: string) {
+  return {
+    serverId,
+    provider: "codex" as const,
+    providerPreferences: TEST_PROVIDER_PREFERENCES,
+  };
+}

packages/app/e2e/helpers/node-ws-factory.ts

@@ -0,0 +1,27 @@
+import WebSocket from "ws";
+
+type WebSocketLike = {
+  readyState: number;
+  send: (data: string | Uint8Array | ArrayBuffer) => void;
+  close: (code?: number, reason?: string) => void;
+  binaryType?: string;
+  on?: (event: string, listener: (...args: any[]) => void) => void;
+  off?: (event: string, listener: (...args: any[]) => void) => void;
+  removeListener?: (event: string, listener: (...args: any[]) => void) => void;
+  addEventListener?: (event: string, listener: (event: any) => void) => void;
+  removeEventListener?: (event: string, listener: (event: any) => void) => void;
+  onopen?: ((event: any) => void) | null;
+  onclose?: ((event: any) => void) | null;
+  onerror?: ((event: any) => void) | null;
+  onmessage?: ((event: any) => void) | null;
+};
+
+export type NodeWebSocketFactory = (
+  url: string,
+  options?: { headers?: Record<string, string> },
+) => WebSocketLike;
+
+export function createNodeWebSocketFactory(): NodeWebSocketFactory {
+  return (url: string, options?: { headers?: Record<string, string> }) =>
+    new WebSocket(url, { headers: options?.headers }) as unknown as WebSocketLike;
+}

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

@@ -0,0 +1,237 @@
+import type { Page } from "@playwright/test";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { randomUUID } from "node:crypto";
+import { createNodeWebSocketFactory, type NodeWebSocketFactory } from "./node-ws-factory";
+import { buildHostWorkspaceRoute } from "../../src/utils/host-routes";
+
+export type TerminalPerfDaemonClient = {
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  createTerminal(
+    cwd: string,
+    name?: string,
+  ): Promise<{
+    terminal: { id: string; name: string; cwd: string } | null;
+    error: string | null;
+  }>;
+  subscribeTerminal(
+    terminalId: string,
+  ): Promise<{ terminalId: string; slot: number; error: null } | { error: string }>;
+  sendTerminalInput(
+    terminalId: string,
+    message: { type: "input"; data: string } | { type: "resize"; rows: number; cols: number },
+  ): void;
+  onTerminalStreamEvent(
+    handler: (event: { terminalId: string; type: string; data?: Uint8Array }) => void,
+  ): () => void;
+  killTerminal(terminalId: string): Promise<{ error: string | null }>;
+};
+
+function getDaemonWsUrl(): string {
+  const daemonPort = process.env.E2E_DAEMON_PORT;
+  if (!daemonPort) {
+    throw new Error("E2E_DAEMON_PORT is not set.");
+  }
+  return `ws://127.0.0.1:${daemonPort}/ws`;
+}
+
+function getServerId(): string {
+  const serverId = process.env.E2E_SERVER_ID;
+  if (!serverId) {
+    throw new Error("E2E_SERVER_ID is not set.");
+  }
+  return serverId;
+}
+
+type TerminalPerfDaemonClientConfig = {
+  url: string;
+  clientId: string;
+  clientType: "cli";
+  webSocketFactory?: NodeWebSocketFactory;
+};
+
+async function loadDaemonClientConstructor(): Promise<
+  new (
+    config: TerminalPerfDaemonClientConfig,
+  ) => TerminalPerfDaemonClient
+> {
+  const repoRoot = path.resolve(__dirname, "../../../../");
+  const moduleUrl = pathToFileURL(
+    path.join(repoRoot, "packages/server/dist/server/server/exports.js"),
+  ).href;
+  const mod = (await import(moduleUrl)) as {
+    DaemonClient: new (config: TerminalPerfDaemonClientConfig) => TerminalPerfDaemonClient;
+  };
+  return mod.DaemonClient;
+}
+
+export async function connectTerminalClient(): Promise<TerminalPerfDaemonClient> {
+  const DaemonClient = await loadDaemonClientConstructor();
+  const webSocketFactory = createNodeWebSocketFactory();
+  const client = new DaemonClient({
+    url: getDaemonWsUrl(),
+    clientId: `terminal-perf-${randomUUID()}`,
+    clientType: "cli",
+    webSocketFactory,
+  });
+  await client.connect();
+  return client;
+}
+
+export function buildTerminalWorkspaceUrl(cwd: string, terminalId: string): string {
+  const serverId = getServerId();
+  const route = buildHostWorkspaceRoute(serverId, cwd);
+  return `${route}?open=${encodeURIComponent(`terminal:${terminalId}`)}`;
+}
+
+function buildWorkspaceUrl(cwd: string): string {
+  return buildHostWorkspaceRoute(getServerId(), cwd);
+}
+
+export async function getTerminalBufferText(page: Page): Promise<string> {
+  return page.evaluate(() => {
+    const term = (window as any).__paseoTerminal;
+    if (!term) {
+      return "";
+    }
+    const buf = term.buffer.active;
+    const lines: string[] = [];
+    for (let i = 0; i < buf.length; i++) {
+      const line = buf.getLine(i);
+      if (line) {
+        lines.push(line.translateToString(true));
+      }
+    }
+    return lines.join("\n");
+  });
+}
+
+export async function waitForTerminalContent(
+  page: Page,
+  predicate: (text: string) => boolean,
+  timeout: number,
+): Promise<void> {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    const text = await getTerminalBufferText(page);
+    if (predicate(text)) {
+      return;
+    }
+    await page.waitForTimeout(50);
+  }
+  throw new Error(`Terminal content did not match predicate within ${timeout}ms`);
+}
+
+export async function navigateToTerminal(
+  page: Page,
+  input: { cwd: string; terminalId: string },
+): Promise<void> {
+  // Boot the app at the workspace route directly.
+  // The fixtures.ts beforeEach addInitScript seeds localStorage on every navigation,
+  // so the daemon registry is already configured when the app starts.
+  const workspaceRoute = buildTerminalWorkspaceUrl(input.cwd, input.terminalId);
+  await page.goto(workspaceRoute);
+
+  // The workspace layout consumes `?open=...`, returns null during the effect,
+  // then replaces the URL with the clean workspace route after preparing the tab.
+  const cleanWorkspaceRoute = buildWorkspaceUrl(input.cwd);
+  await page.waitForURL(
+    (url) => url.pathname === cleanWorkspaceRoute && !url.searchParams.has("open"),
+    { timeout: 15_000 },
+  );
+
+  // Wait for daemon connection (sidebar shows host label)
+  await page
+    .getByText("localhost", { exact: true })
+    .first()
+    .waitFor({ state: "visible", timeout: 15_000 });
+
+  // The open intent should have prepared and focused the exact pre-created terminal tab.
+  const terminalTab = page.locator(`[data-testid="workspace-tab-terminal_${input.terminalId}"]`);
+  await terminalTab.waitFor({ state: "visible", timeout: 15_000 });
+  await terminalTab.click();
+
+  const terminalSurface = page.locator('[data-testid="terminal-surface"]');
+  await terminalSurface.waitFor({ state: "visible", timeout: 15_000 });
+
+  // Wait for loading overlay to disappear (terminal attached)
+  await page
+    .locator('[data-testid="terminal-attach-loading"]')
+    .waitFor({ state: "hidden", timeout: 10_000 })
+    .catch(() => {
+      // overlay may never appear if attachment is instant
+    });
+
+  await terminalSurface.scrollIntoViewIfNeeded();
+  await terminalSurface.click();
+}
+
+export async function setupDeterministicPrompt(page: Page, sentinel?: string): Promise<void> {
+  const tag = sentinel ?? `READY_${Date.now()}`;
+  const terminal = page.locator('[data-testid="terminal-surface"]');
+
+  await terminal.pressSequentially(`echo ${tag}\n`, { delay: 0 });
+  await waitForTerminalContent(page, (text) => text.includes(tag), 10_000);
+
+  await terminal.pressSequentially("export PS1='$ '\n", { delay: 0 });
+  await page.waitForTimeout(300);
+}
+
+export type LatencySample = {
+  char: string;
+  latencyMs: number;
+};
+
+/**
+ * Measures keystroke echo round-trip latency.
+ *
+ * Starts a high-resolution timer on the browser keydown event (capture phase)
+ * and stops it when xterm.js finishes parsing the echoed write. This measures
+ * the full path: keydown → WebSocket → daemon PTY echo → WebSocket → xterm render.
+ */
+export async function measureKeystrokeLatency(page: Page, char: string): Promise<number> {
+  await page.evaluate(() => {
+    const term = (window as any).__paseoTerminal;
+    if (!term) {
+      throw new Error("__paseoTerminal not available");
+    }
+
+    const state = ((window as any).__perfKeystroke = {
+      promise: null as Promise<number> | null,
+    });
+
+    state.promise = new Promise<number>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        document.removeEventListener("keydown", onKeyDown, true);
+        reject(new Error("keystroke echo timeout (5s)"));
+      }, 5000);
+
+      function onKeyDown() {
+        document.removeEventListener("keydown", onKeyDown, true);
+        const start = performance.now();
+        const disposable = term.onWriteParsed(() => {
+          clearTimeout(timeout);
+          disposable.dispose();
+          resolve(performance.now() - start);
+        });
+      }
+
+      document.addEventListener("keydown", onKeyDown, true);
+    });
+  });
+
+  await page.keyboard.press(char);
+
+  return page.evaluate(() => (window as any).__perfKeystroke.promise);
+}
+
+export function computePercentile(samples: number[], p: number): number {
+  const sorted = [...samples].sort((a, b) => a - b);
+  const index = Math.ceil((p / 100) * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+
+export function round2(value: number): number {
+  return Math.round(value * 100) / 100;
+}

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

@@ -38,7 +38,7 @@ export async function ensureWorkspaceAgentPaneVisible(page: Page): Promise<void>
 
 export async function sampleWorkspaceTabIds(
   page: Page,
-  options: { durationMs?: number; intervalMs?: number } = {}
+  options: { durationMs?: number; intervalMs?: number } = {},
 ): Promise<string[][]> {
   const durationMs = options.durationMs ?? 2_500;
   const intervalMs = options.intervalMs ?? 50;

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

@@ -1,38 +1,38 @@
-import { expect, type Page } from '@playwright/test';
-import { buildHostWorkspaceRoute } from '@/utils/host-routes';
-import { gotoHome } from './app';
+import { expect, type Page } from "@playwright/test";
+import { buildHostWorkspaceRoute } from "@/utils/host-routes";
+import { gotoHome } from "./app";
 
 export async function openNewAgentComposer(page: Page): Promise<void> {
   await gotoHome(page);
 }
 
 export function workspaceLabelFromPath(value: string): string {
-  const normalized = value.replace(/\\/g, '/').replace(/\/+$/, '');
-  const parts = normalized.split('/').filter(Boolean);
+  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+  const parts = normalized.split("/").filter(Boolean);
   return parts[parts.length - 1] ?? normalized;
 }
 
 function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
 function candidateWorkspaceIds(inputPath: string): string[] {
-  const trimmed = inputPath.replace(/\/+$/, '');
+  const trimmed = inputPath.replace(/\/+$/, "");
   const candidates = new Set<string>([trimmed]);
-  if (trimmed.startsWith('/var/')) {
+  if (trimmed.startsWith("/var/")) {
     candidates.add(`/private${trimmed}`);
   }
-  if (trimmed.startsWith('/private/var/')) {
-    candidates.add(trimmed.replace(/^\/private/, ''));
+  if (trimmed.startsWith("/private/var/")) {
+    candidates.add(trimmed.replace(/^\/private/, ""));
   }
   return Array.from(candidates);
 }
 
 function workspaceRowLocator(page: Page, serverId: string, workspacePath: string) {
   const ids = candidateWorkspaceIds(workspacePath).map(
-    (id) => `[data-testid="sidebar-workspace-row-${serverId}:${id}"]`
+    (id) => `[data-testid="sidebar-workspace-row-${serverId}:${id}"]`,
   );
-  return page.locator(ids.join(',')).first();
+  return page.locator(ids.join(",")).first();
 }
 
 export async function switchWorkspaceViaSidebar(input: {
@@ -52,10 +52,10 @@ export async function switchWorkspaceViaSidebar(input: {
 
 export async function expectWorkspaceHeader(
   page: Page,
-  input: { title: string; subtitle: string }
+  input: { title: string; subtitle: string },
 ): Promise<void> {
-  const titleLocator = page.getByTestId('workspace-header-title');
-  const subtitleLocator = page.getByTestId('workspace-header-subtitle');
+  const titleLocator = page.getByTestId("workspace-header-title");
+  const subtitleLocator = page.getByTestId("workspace-header-subtitle");
 
   await expect(titleLocator.first()).toHaveText(input.title, {
     timeout: 30_000,
@@ -66,9 +66,9 @@ export async function expectWorkspaceHeader(
 }
 
 export async function seedWorkspaceActivity(page: Page, marker: string): Promise<void> {
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
+  const input = page.getByRole("textbox", { name: "Message agent..." });
   await expect(input).toBeEditable({ timeout: 30_000 });
   await input.fill(marker);
-  await input.press('Enter');
+  await input.press("Enter");
   await expect(page).toHaveURL(/\/workspace\//, { timeout: 30_000 });
 }

packages/app/e2e/helpers/workspace.ts

@@ -1,7 +1,7 @@
-import { execSync } from 'node:child_process';
-import { mkdtemp, writeFile, rm, mkdir } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
+import { execSync } from "node:child_process";
+import { mkdtemp, writeFile, rm, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
 
 type TempRepo = {
   path: string;
@@ -9,29 +9,29 @@ type TempRepo = {
 };
 
 export const createTempGitRepo = async (
-  prefix = 'paseo-e2e-',
-  options?: { withRemote?: boolean }
+  prefix = "paseo-e2e-",
+  options?: { withRemote?: boolean },
 ): Promise<TempRepo> => {
   // Keep E2E repo paths short so terminal prompt + typed commands stay visible without zsh clipping.
-  const tempRoot = process.platform === 'win32' ? tmpdir() : '/tmp';
+  const tempRoot = process.platform === "win32" ? tmpdir() : "/tmp";
   const repoPath = await mkdtemp(path.join(tempRoot, prefix));
   const withRemote = options?.withRemote ?? false;
 
-  execSync('git init -b main', { cwd: repoPath, stdio: 'ignore' });
-  execSync('git config user.email "e2e@paseo.test"', { cwd: repoPath, stdio: 'ignore' });
-  execSync('git config user.name "Paseo E2E"', { cwd: repoPath, stdio: 'ignore' });
-  execSync('git config commit.gpgsign false', { cwd: repoPath, stdio: 'ignore' });
-  await writeFile(path.join(repoPath, 'README.md'), '# Temp Repo\n');
-  execSync('git add README.md', { cwd: repoPath, stdio: 'ignore' });
-  execSync('git commit -m "Initial commit"', { cwd: repoPath, stdio: 'ignore' });
+  execSync("git init -b main", { cwd: repoPath, stdio: "ignore" });
+  execSync('git config user.email "e2e@paseo.test"', { cwd: repoPath, stdio: "ignore" });
+  execSync('git config user.name "Paseo E2E"', { cwd: repoPath, stdio: "ignore" });
+  execSync("git config commit.gpgsign false", { cwd: repoPath, stdio: "ignore" });
+  await writeFile(path.join(repoPath, "README.md"), "# Temp Repo\n");
+  execSync("git add README.md", { cwd: repoPath, stdio: "ignore" });
+  execSync('git commit -m "Initial commit"', { cwd: repoPath, stdio: "ignore" });
 
   if (withRemote) {
     // Deterministic local remote to avoid relying on external auth/network in e2e.
-    const remoteDir = path.join(repoPath, 'remote.git');
+    const remoteDir = path.join(repoPath, "remote.git");
     await mkdir(remoteDir, { recursive: true });
-    execSync(`git init --bare -b main ${remoteDir}`, { cwd: repoPath, stdio: 'ignore' });
-    execSync(`git remote add origin ${remoteDir}`, { cwd: repoPath, stdio: 'ignore' });
-    execSync('git push -u origin main', { cwd: repoPath, stdio: 'ignore' });
+    execSync(`git init --bare -b main ${remoteDir}`, { cwd: repoPath, stdio: "ignore" });
+    execSync(`git remote add origin ${remoteDir}`, { cwd: repoPath, stdio: "ignore" });
+    execSync("git push -u origin main", { cwd: repoPath, stdio: "ignore" });
   }
 
   return {

packages/app/e2e/host-onboarding-direct.spec.ts

@@ -1,44 +0,0 @@
-import { test, expect } from './fixtures';
-
-test('no hosts shows welcome; direct connection adds host and lands on agent create', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  await page.addInitScript(() => {
-    localStorage.setItem('@paseo:daemon-registry', JSON.stringify([]));
-    localStorage.removeItem('@paseo:create-agent-preferences');
-    localStorage.removeItem('@paseo:settings');
-  });
-
-  await page.goto('/');
-
-  await expect(page.getByText('Welcome to Paseo', { exact: true })).toBeVisible();
-
-  await page.getByText('Direct connection', { exact: true }).click();
-
-  await page.getByPlaceholder('host:6767').fill(`127.0.0.1:${daemonPort}`);
-
-  await page.getByText('Connect', { exact: true }).click();
-
-  // First-time connection prompts for an optional label.
-  const nameModal = page.getByTestId('name-host-modal');
-  const showedNameModal = await nameModal
-    .waitFor({ state: 'visible', timeout: 5000 })
-    .then(() => true)
-    .catch(() => false);
-  if (showedNameModal) {
-    await nameModal.getByTestId('name-host-skip').click();
-  }
-
-  await expect(page.getByTestId('sidebar-new-agent')).toBeVisible();
-  await expect(page.getByText(serverId, { exact: true })).toBeVisible();
-  await expect(page.getByRole('textbox', { name: 'Message agent...' })).toBeEditable({
-    timeout: 15000,
-  });
-});

packages/app/e2e/host-removal.spec.ts

@@ -1,119 +0,0 @@
-import { test, expect } from './fixtures';
-
-test('host removal removes the host from UI and persists after reload', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const seededServerId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!seededServerId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  const extraPort = Number(daemonPort) + 1;
-  const extraEndpoint = `127.0.0.1:${extraPort}`;
-  const nowIso = new Date().toISOString();
-
-  const extraDaemon = {
-    serverId: 'srv_e2e_extra_daemon',
-    label: 'extra',
-    connections: [
-      { id: `direct:${extraEndpoint}`, type: 'direct', endpoint: extraEndpoint },
-    ],
-    preferredConnectionId: `direct:${extraEndpoint}`,
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  const seededTestDaemon = {
-    serverId: seededServerId,
-    label: 'localhost',
-    connections: [
-      { id: `direct:127.0.0.1:${daemonPort}`, type: 'direct', endpoint: `127.0.0.1:${daemonPort}` },
-    ],
-    preferredConnectionId: `direct:127.0.0.1:${daemonPort}`,
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  const seedOnceKey = `@paseo:e2e-host-removal-seeded:${Math.random().toString(36).slice(2)}`;
-
-  // Add a second host once (fixtures seed the primary host on every navigation).
-  await page.addInitScript(
-    ({ daemon, seededTestDaemon, seedOnceKey }) => {
-      if (localStorage.getItem(seedOnceKey)) {
-        return;
-      }
-
-      const raw = localStorage.getItem('@paseo:daemon-registry');
-      let parsed: any[] = [];
-      if (raw) {
-        try {
-          parsed = JSON.parse(raw);
-        } catch {
-          parsed = [];
-        }
-      }
-      const list = Array.isArray(parsed) ? parsed : [];
-      localStorage.setItem(seedOnceKey, '1');
-
-      const next = [...list];
-      const hasSeeded = next.some((entry: any) => entry && entry.serverId === seededTestDaemon.serverId);
-      if (!hasSeeded) {
-        next.push(seededTestDaemon);
-      }
-
-      const alreadyPresent = next.some((entry: any) => entry && entry.serverId === daemon.serverId);
-      if (!alreadyPresent) {
-        next.push(daemon);
-      }
-
-      localStorage.setItem('@paseo:daemon-registry', JSON.stringify(next));
-    },
-    { daemon: extraDaemon, seededTestDaemon, seedOnceKey }
-  );
-
-  await page.goto('/settings');
-
-  await expect(page.getByText('extra', { exact: true }).first()).toBeVisible();
-  await expect(page.getByText(extraEndpoint, { exact: true }).first()).toBeVisible();
-
-  const hostSettingsButton = page.getByTestId(`daemon-card-settings-${extraDaemon.serverId}`).first();
-  await expect(hostSettingsButton).toBeVisible({ timeout: 10000 });
-  await hostSettingsButton.click();
-
-  const hostDetailModal = page.getByTestId('host-detail-modal');
-  await expect(hostDetailModal).toBeVisible({ timeout: 10000 });
-  await hostDetailModal.getByText('Advanced', { exact: true }).click();
-  await page.getByText('Remove host', { exact: true }).last().click();
-
-  await expect(page.getByTestId('remove-host-confirm-modal')).toBeVisible();
-  await page.getByTestId('remove-host-confirm').click();
-
-  await expect(page.getByTestId(`daemon-card-${extraDaemon.serverId}`)).toHaveCount(0, {
-    timeout: 30000,
-  });
-  await expect(page.getByText(extraEndpoint, { exact: true })).toHaveCount(0);
-  await page.waitForFunction(
-    (serverId) => {
-      const raw = localStorage.getItem('@paseo:daemon-registry');
-      if (!raw) return false;
-      try {
-        const parsed = JSON.parse(raw);
-        return Array.isArray(parsed) && !parsed.some((entry: any) => entry && entry.serverId === serverId);
-      } catch {
-        return false;
-      }
-    },
-    extraDaemon.serverId,
-    { timeout: 10000 }
-  );
-
-  // Prevent the fixture from overwriting storage on reload; verify persistence.
-  await page.evaluate(() => {
-    const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-    localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-  });
-  await page.reload();
-  await expect(page.getByText(extraEndpoint, { exact: true })).toHaveCount(0);
-});

packages/app/e2e/host-selection.spec.ts

@@ -1,124 +0,0 @@
-import { test, expect } from './fixtures';
-import { ensureHostSelected, gotoHome } from './helpers/app';
-
-test('new agent auto-selects the previous host', async ({ page }) => {
-  await gotoHome(page);
-  await ensureHostSelected(page);
-
-  await gotoHome(page);
-
-  // The selected host should be restored after a full reload without manual selection.
-  await expect(page.getByText('localhost', { exact: true }).first()).toBeVisible();
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
-  await expect(input).toBeEditable({ timeout: 30000 });
-});
-
-test('new agent respects serverId in the URL', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  // Ensure this test's storage is deterministic even under parallel load.
-  const nowIso = new Date().toISOString();
-  const testDaemon = {
-    serverId,
-    label: 'localhost',
-    connections: [
-      {
-        id: `direct:127.0.0.1:${daemonPort}`,
-        type: 'direct',
-        endpoint: `127.0.0.1:${daemonPort}`,
-      },
-    ],
-    preferredConnectionId: `direct:127.0.0.1:${daemonPort}`,
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-  const createAgentPreferences = {
-    serverId: testDaemon.serverId,
-    provider: 'codex',
-    providerPreferences: {
-      claude: { model: 'haiku' },
-      codex: { model: 'gpt-5.1-codex-mini', thinkingOptionId: 'low' },
-    },
-  };
-
-  await page.goto('/settings');
-  await page.evaluate(
-    ({ daemon, preferences }) => {
-      const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-      localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-      localStorage.setItem('@paseo:daemon-registry', JSON.stringify([daemon]));
-      localStorage.setItem('@paseo:create-agent-preferences', JSON.stringify(preferences));
-      localStorage.removeItem('@paseo:settings');
-    },
-    { daemon: testDaemon, preferences: createAgentPreferences }
-  );
-  await page.reload();
-  await expect(page.getByText('New agent', { exact: true }).first()).toBeVisible({ timeout: 20000 });
-
-  await page.goto(`/?serverId=${encodeURIComponent(serverId)}`);
-  await expect(page.getByText('New agent', { exact: true }).first()).toBeVisible();
-
-  const newAgentButton = page.getByTestId('sidebar-new-agent').first();
-  if (await newAgentButton.isVisible().catch(() => false)) {
-    await newAgentButton.click();
-  } else {
-    await page.getByText('New agent', { exact: true }).first().click();
-  }
-
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
-  await expect(input).toBeEditable({ timeout: 30000 });
-});
-
-test('new agent auto-selects first online host when no preference is stored', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  const nowIso = new Date().toISOString();
-  const testDaemon = {
-    serverId,
-    label: 'localhost',
-    connections: [
-      {
-        id: `direct:127.0.0.1:${daemonPort}`,
-        type: 'direct',
-        endpoint: `127.0.0.1:${daemonPort}`,
-      },
-    ],
-    preferredConnectionId: `direct:127.0.0.1:${daemonPort}`,
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  await gotoHome(page);
-  await page.evaluate(
-    ({ daemon }) => {
-      const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-      localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-      localStorage.setItem('@paseo:daemon-registry', JSON.stringify([daemon]));
-      localStorage.removeItem('@paseo:create-agent-preferences');
-      localStorage.removeItem('@paseo:settings');
-    },
-    { daemon: testDaemon }
-  );
-
-  await page.reload();
-  await expect(page.getByText('New agent', { exact: true }).first()).toBeVisible();
-
-  // Host should be auto-selected (no manual selection required).
-  await expect(page.getByText('localhost', { exact: true }).first()).toBeVisible();
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
-  await expect(input).toBeEditable({ timeout: 30000 });
-});

packages/app/e2e/keyboard-shortcuts-dialog.spec.ts

@@ -1,17 +0,0 @@
-import { test, expect } from "./fixtures";
-import { gotoHome } from "./helpers/app";
-
-test("question mark opens keyboard shortcuts dialog", async ({ page }) => {
-  await gotoHome(page);
-  await page.getByTestId("menu-button").first().focus();
-
-  await page.keyboard.press("Shift+/");
-
-  const dialog = page.getByTestId("keyboard-shortcuts-dialog");
-  const content = page.getByTestId("keyboard-shortcuts-dialog-content");
-
-  await expect(dialog).toBeVisible({ timeout: 10000 });
-  await expect(content).toBeVisible({ timeout: 10000 });
-  await expect(content).toContainText("Show keyboard shortcuts");
-  await expect(content).toContainText("Toggle left sidebar");
-});

packages/app/e2e/manual-host-port.spec.ts

@@ -1,85 +0,0 @@
-import { test, expect } from './fixtures';
-
-test('manual host add accepts host:port only and persists a direct connection', async ({ page }) => {
-  const daemonPort = process.env.E2E_DAEMON_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!daemonPort) {
-    throw new Error('E2E_DAEMON_PORT is not set (expected from globalSetup).');
-  }
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set (expected from globalSetup).');
-  }
-
-  // Override the default fixture seeding for this navigation (must run before app boot).
-  await page.addInitScript(() => {
-    localStorage.setItem('@paseo:daemon-registry', JSON.stringify([]));
-    localStorage.removeItem('@paseo:settings');
-  });
-  await page.goto('/settings');
-
-  await expect
-    .poll(
-      async () => {
-        if (await page.getByText('Welcome to Paseo', { exact: true }).isVisible().catch(() => false)) {
-          return 'welcome';
-        }
-        if (await page.getByText('+ Add connection', { exact: true }).isVisible().catch(() => false)) {
-          return 'settings';
-        }
-        return '';
-      },
-      { timeout: 15000 }
-    )
-    .not.toBe('');
-
-  const isWelcome = await page.getByText('Welcome to Paseo', { exact: true }).isVisible().catch(() => false);
-  if (isWelcome) {
-    await page.getByText('Direct connection', { exact: true }).first().click();
-  } else {
-    await page.getByText('+ Add connection', { exact: true }).click();
-    await page.getByText('Direct connection', { exact: true }).click();
-  }
-
-  const input = page.getByPlaceholder('host:6767');
-  await expect(input).toBeVisible();
-  await input.fill(`127.0.0.1:${daemonPort}`);
-
-  await page.getByText('Connect', { exact: true }).click();
-
-  const nameModal = page.getByTestId('name-host-modal');
-  if (await nameModal.isVisible().catch(() => false)) {
-    await nameModal.getByTestId('name-host-skip').click();
-  }
-
-  await expect(page.getByTestId('sidebar-new-agent')).toBeVisible({ timeout: 30000 });
-
-  const settingsButton = page.locator('[data-testid="sidebar-settings"]:visible').first();
-  await expect(settingsButton).toBeVisible({ timeout: 10000 });
-  await settingsButton.click();
-  await expect(page.locator(`[data-testid="daemon-card-${serverId}"]:visible`).first()).toBeVisible({
-    timeout: 15000,
-  });
-
-  await page.waitForFunction(
-    ({ port, serverId }) => {
-      const raw = localStorage.getItem('@paseo:daemon-registry');
-      if (!raw) return false;
-      try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed) || parsed.length !== 1) return false;
-        const entry = parsed[0];
-        return (
-          entry?.serverId === serverId &&
-          Array.isArray(entry?.connections) &&
-          entry.connections.some(
-            (conn: any) => conn?.type === 'direct' && conn?.endpoint === `127.0.0.1:${port}`
-          )
-        );
-      } catch {
-        return false;
-      }
-    },
-    { port: daemonPort, serverId },
-    { timeout: 10000 }
-  );
-});

packages/app/e2e/pairing-offer-parsing.spec.ts

@@ -1,91 +0,0 @@
-import { test, expect } from './fixtures';
-import { Buffer } from 'node:buffer';
-import { gotoHome, openSettings } from './helpers/app';
-
-function encodeBase64Url(input: string): string {
-  return Buffer.from(input, 'utf8')
-    .toString('base64')
-    .replace(/\+/g, '-')
-    .replace(/\//g, '_')
-    .replace(/=+$/g, '');
-}
-
-test('pairing flow accepts #offer=ConnectionOfferV2 and stores relay-only host', async ({ page }) => {
-  const relayPort = process.env.E2E_RELAY_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  const daemonPublicKeyB64 = process.env.E2E_RELAY_DAEMON_PUBLIC_KEY;
-  if (!relayPort || !serverId || !daemonPublicKeyB64) {
-    throw new Error(
-      'E2E_RELAY_PORT, E2E_SERVER_ID, or E2E_RELAY_DAEMON_PUBLIC_KEY is not set (expected from globalSetup).'
-    );
-  }
-
-  // Override the default fixture seeding for this test.
-  await gotoHome(page);
-  await openSettings(page);
-  await page.evaluate(() => {
-    const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-    localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-    localStorage.setItem('@paseo:daemon-registry', JSON.stringify([]));
-    localStorage.removeItem('@paseo:settings');
-  });
-  await page.goto('/');
-
-  const relayEndpoint = `127.0.0.1:${relayPort}`;
-
-  const offer = {
-    v: 2 as const,
-    serverId,
-    daemonPublicKeyB64,
-    relay: { endpoint: relayEndpoint },
-  };
-
-  const offerUrl = `https://app.paseo.sh/#offer=${encodeBase64Url(JSON.stringify(offer))}`;
-
-  const welcomeTitle = page.getByText('Welcome to Paseo', { exact: true });
-  if (await welcomeTitle.isVisible().catch(() => false)) {
-    await page.getByTestId('welcome-paste-pairing-link').click();
-  } else {
-    await page.getByText('+ Add connection', { exact: true }).click();
-    await page.getByText('Paste pairing link', { exact: true }).click();
-  }
-
-  const input = page.getByPlaceholder('https://app.paseo.sh/#offer=...');
-  await expect(input).toBeVisible();
-  await input.fill(offerUrl);
-
-  await page.getByTestId('pair-link-submit').click();
-
-  const nameHostModal = page.getByTestId('name-host-modal');
-  if (await nameHostModal.isVisible().catch(() => false)) {
-    await nameHostModal.getByTestId('name-host-skip').click();
-  }
-
-  await expect(page.getByTestId('sidebar-new-agent')).toBeVisible({ timeout: 30000 });
-
-  await page.waitForFunction(
-    ({ expected }) => {
-      const raw = localStorage.getItem('@paseo:daemon-registry');
-      if (!raw) return false;
-      try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed) || parsed.length !== 1) return false;
-        const entry = parsed[0];
-        const relayId = `relay:${expected.relay.endpoint}`;
-        return (
-          entry?.serverId === expected.serverId &&
-          Array.isArray(entry?.connections) &&
-          entry.connections.length === 1 &&
-          entry.connections[0]?.id === relayId &&
-          entry.connections[0]?.type === 'relay' &&
-          entry.connections[0]?.relayEndpoint === expected.relay.endpoint &&
-          entry.connections[0]?.daemonPublicKeyB64 === expected.daemonPublicKeyB64
-        );
-      } catch {
-        return false;
-      }
-    },
-    { expected: offer },
-    { timeout: 10000 }
-  );
-});

packages/app/e2e/paste-image-attachment.spec.ts

@@ -1,53 +0,0 @@
-import { test, expect } from "./fixtures";
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-
-test("pastes clipboard image into prompt attachments", async ({ page }) => {
-  const repo = await createTempGitRepo("paseo-e2e-paste-image-");
-
-  try {
-    await gotoHome(page);
-    await setWorkingDirectory(page, repo.path);
-    await ensureHostSelected(page);
-
-    const input = page.getByRole("textbox", { name: "Message agent..." });
-    await expect(input).toBeEditable();
-    await input.focus();
-
-    const result = await page.evaluate(() => {
-      const active = document.activeElement;
-      if (!(active instanceof HTMLTextAreaElement)) {
-        return {
-          pasted: false,
-          elementTag: active ? active.tagName : null,
-          defaultPrevented: false,
-        };
-      }
-
-      const file = new File([new Uint8Array([0, 1, 2, 3])], "paste.png", {
-        type: "image/png",
-      });
-      const dataTransfer = new DataTransfer();
-      dataTransfer.items.add(file);
-
-      const event = new ClipboardEvent("paste", {
-        clipboardData: dataTransfer,
-        bubbles: true,
-        cancelable: true,
-      });
-      active.dispatchEvent(event);
-
-      return {
-        pasted: true,
-        elementTag: active.tagName,
-        defaultPrevented: event.defaultPrevented,
-      };
-    });
-
-    expect(result.pasted).toBe(true);
-    expect(result.defaultPrevented).toBe(true);
-    await expect(page.getByTestId("message-input-image-pill")).toHaveCount(1);
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/permission-prompt.spec.ts

@@ -1,92 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { test, expect } from './fixtures';
-import {
-  createAgentWithConfig,
-  waitForPermissionPrompt,
-  allowPermission,
-  denyPermission,
-  waitForAgentFinishUI,
-} from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-const FILE_CONTENT = 'Hello from permission test';
-
-function buildWriteCommand(filePath: string): string {
-  return `bash -lc 'sleep 2; printf "${FILE_CONTENT}" > "${filePath}"'`;
-}
-
-test.describe('permission prompts', () => {
-  test('allow permission creates the file', async ({ page }) => {
-    const repo = await createTempGitRepo();
-    const uniqueFilename = `test-allow-${Date.now()}.txt`;
-    const filePath = path.join(repo.path, uniqueFilename);
-    const shellCommand = buildWriteCommand(filePath);
-    const prompt = [
-      `Use your shell tool to run exactly this command:`,
-      shellCommand,
-      `Do not write outside this exact path.`,
-    ].join(' ');
-
-    try {
-      await createAgentWithConfig(page, {
-        directory: repo.path,
-        provider: 'claude',
-        mode: 'Always Ask',
-        prompt,
-      });
-
-      await waitForPermissionPrompt(page, 30000);
-
-      await allowPermission(page);
-
-      // Wait for file to be created
-      await expect
-        .poll(() => existsSync(filePath), {
-          message: `File ${filePath} should exist after allowing permission`,
-          timeout: 30000,
-        })
-        .toBe(true);
-
-      // After allowing, the file should be created successfully
-      // The tool call count might still be 1 if the UI updates quickly
-      const fileContent = await readFile(filePath, 'utf-8');
-      expect(fileContent.trim()).toBe(FILE_CONTENT);
-    } finally {
-      await repo.cleanup();
-    }
-  });
-
-  test('deny permission does not create the file', async ({ page }) => {
-    const repo = await createTempGitRepo();
-    const uniqueFilename = `test-deny-${Date.now()}.txt`;
-    const filePath = path.join(repo.path, uniqueFilename);
-    const shellCommand = buildWriteCommand(filePath);
-    const prompt = [
-      `Use your shell tool to run exactly this command:`,
-      shellCommand,
-      `Do not write outside this exact path.`,
-    ].join(' ');
-
-    try {
-      await createAgentWithConfig(page, {
-        directory: repo.path,
-        provider: 'claude',
-        mode: 'Always Ask',
-        prompt,
-      });
-
-      await waitForPermissionPrompt(page, 30000);
-
-      await denyPermission(page);
-      await waitForAgentFinishUI(page, 30000);
-      await expect(page.getByTestId('permission-request-question')).toHaveCount(0);
-
-      expect(existsSync(filePath)).toBe(false);
-
-    } finally {
-      await repo.cleanup();
-    }
-  });
-});

packages/app/e2e/preserve-prompt-on-error.spec.ts

@@ -1,25 +0,0 @@
-import { test, expect } from './fixtures';
-import { gotoHome, ensureHostSelected, setWorkingDirectory } from './helpers/app';
-
-test('preserves prompt text when trying to create agent with non-existent directory', async ({ page }) => {
-  const nonExistentDir = '/non/existent/directory/that/does/not/exist';
-  const promptText = `Test prompt that should be preserved ${Date.now()}`;
-
-  await gotoHome(page);
-  await ensureHostSelected(page);
-  await setWorkingDirectory(page, nonExistentDir);
-
-  // Enter prompt text
-  const input = page.getByRole('textbox', { name: 'Message agent...' });
-  await expect(input).toBeEditable();
-  await input.fill(promptText);
-
-  // Try to submit - this should fail with an error about the directory not existing
-  await input.press('Enter');
-
-  // Verify error message is displayed (error includes the path)
-  await expect(page.getByText(/Working directory does not exist/)).toBeVisible();
-
-  // Verify the prompt text is still preserved in the input
-  await expect(input).toHaveValue(promptText);
-});

packages/app/e2e/relay-fallback-connect.spec.ts

@@ -1,44 +0,0 @@
-import { test, expect } from './fixtures';
-import { gotoHome, openSettings } from './helpers/app';
-
-test('connects via relay when direct endpoints fail', async ({ page }) => {
-  const relayPort = process.env.E2E_RELAY_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  const daemonPublicKeyB64 = process.env.E2E_RELAY_DAEMON_PUBLIC_KEY;
-  if (!relayPort || !serverId || !daemonPublicKeyB64) {
-    throw new Error(
-      'E2E_RELAY_PORT, E2E_SERVER_ID, or E2E_RELAY_DAEMON_PUBLIC_KEY is not set (expected from globalSetup).'
-    );
-  }
-
-  const nowIso = new Date().toISOString();
-  const relayEndpoint = `127.0.0.1:${relayPort}`;
-
-  const host = {
-    serverId,
-    label: 'relay-daemon',
-    connections: [
-      { id: 'direct:127.0.0.1:9', type: 'direct', endpoint: '127.0.0.1:9' },
-      { id: `relay:${relayEndpoint}`, type: 'relay', relayEndpoint, daemonPublicKeyB64 },
-    ],
-    preferredConnectionId: 'direct:127.0.0.1:9',
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  // Override the default fixture seeding for this test.
-  await gotoHome(page);
-  await openSettings(page);
-  await page.evaluate((daemon) => {
-    const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-    localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-    localStorage.setItem('@paseo:daemon-registry', JSON.stringify([daemon]));
-    localStorage.removeItem('@paseo:settings');
-  }, host);
-  await page.reload();
-
-  // Should eventually connect through the relay connection.
-  const card = page.getByTestId(`daemon-card-${serverId}`);
-  await expect(card.getByText('Relay', { exact: true })).toBeVisible({ timeout: 20000 });
-  await expect(card.getByText('Online', { exact: true })).toBeVisible({ timeout: 20000 });
-});

packages/app/e2e/relay-stability.spec.ts

@@ -1,62 +0,0 @@
-import { test, expect } from './fixtures';
-import { gotoHome, openSettings } from './helpers/app';
-
-test('relay connection stays stable across multiple tabs', async ({ page }) => {
-  const relayPort = process.env.E2E_RELAY_PORT;
-  const serverId = process.env.E2E_SERVER_ID;
-  const daemonPublicKeyB64 = process.env.E2E_RELAY_DAEMON_PUBLIC_KEY;
-  if (!relayPort || !serverId || !daemonPublicKeyB64) {
-    throw new Error(
-      'E2E_RELAY_PORT, E2E_SERVER_ID, or E2E_RELAY_DAEMON_PUBLIC_KEY is not set (expected from globalSetup).'
-    );
-  }
-
-  const nowIso = new Date().toISOString();
-  const relayEndpoint = `127.0.0.1:${relayPort}`;
-
-  const host = {
-    serverId,
-    label: 'relay-daemon',
-    connections: [
-      { id: 'direct:127.0.0.1:9', type: 'direct', endpoint: '127.0.0.1:9' },
-      { id: `relay:${relayEndpoint}`, type: 'relay', relayEndpoint, daemonPublicKeyB64 },
-    ],
-    preferredConnectionId: 'direct:127.0.0.1:9',
-    createdAt: nowIso,
-    updatedAt: nowIso,
-  };
-
-  // Use relay by making the direct endpoint intentionally fail.
-  await gotoHome(page);
-  await openSettings(page);
-  await page.evaluate((daemon) => {
-    const nonce = localStorage.getItem('@paseo:e2e-seed-nonce') ?? '1';
-    localStorage.setItem('@paseo:e2e-disable-default-seed-once', nonce);
-    localStorage.setItem('@paseo:daemon-registry', JSON.stringify([daemon]));
-    localStorage.removeItem('@paseo:settings');
-  }, host);
-  await page.reload();
-
-  const card = page.getByTestId(`daemon-card-${serverId}`);
-  await expect(card.getByText('Relay', { exact: true })).toBeVisible({ timeout: 20000 });
-  await expect(card.getByText('Online', { exact: true })).toBeVisible({ timeout: 20000 });
-
-  // Open a second tab. It should be able to connect independently without forcing disconnect churn.
-  const page2 = await page.context().newPage();
-  await page2.route(/:(6767)\b/, (route) => route.abort());
-  await page2.routeWebSocket(/:(6767)\b/, async (ws) => {
-    await ws.close({ code: 1008, reason: 'Blocked connection to localhost:6767 during e2e.' });
-  });
-  await page2.goto('/');
-  const settingsButton2 = page2.locator('[data-testid="sidebar-settings"]:visible').first();
-  await expect(settingsButton2).toBeVisible({ timeout: 20000 });
-  await settingsButton2.click();
-  const card2 = page2.getByTestId(`daemon-card-${serverId}`);
-  await expect(card2.getByText('Relay', { exact: true })).toBeVisible({ timeout: 20000 });
-  await expect(card2.getByText('Online', { exact: true })).toBeVisible({ timeout: 20000 });
-
-  // Stability window: keep both tabs open and ensure they remain online.
-  await page.waitForTimeout(30_000);
-  await expect(card.getByText('Online', { exact: true })).toBeVisible();
-  await expect(card2.getByText('Online', { exact: true })).toBeVisible();
-});

packages/app/e2e/sidebar-new-agent-clones-selected.spec.ts

@@ -1,39 +0,0 @@
-import { test, expect } from './fixtures';
-import { createAgent, ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-
-test('sidebar New Agent opens a fresh create screen', async ({ page }) => {
-  const repoA = await createTempGitRepo();
-
-  try {
-    await gotoHome(page);
-    await ensureHostSelected(page);
-
-    await setWorkingDirectory(page, repoA.path);
-    await createAgent(page, 'Agent A: respond with exactly A');
-    await expect(page).toHaveURL(/\/agent\//);
-
-    // Click sidebar New Agent and assert it re-opens the host draft route while
-    // preserving working directory context from the selected agent.
-    await page.getByTestId('sidebar-new-agent').click();
-    await expect(page).toHaveURL(/\/h\/[^/]+\/agent(\?|$)/);
-    const searchWorkingDir = await page.evaluate(() => {
-      try {
-        return new URL(window.location.href).searchParams.get('workingDir');
-      } catch {
-        return null;
-      }
-    });
-    const normalizedCandidates = new Set<string>([repoA.path]);
-    if (repoA.path.startsWith('/var/')) {
-      normalizedCandidates.add(`/private${repoA.path}`);
-    }
-    if (repoA.path.startsWith('/private/var/')) {
-      normalizedCandidates.add(repoA.path.replace(/^\/private/, ''));
-    }
-    expect(searchWorkingDir).not.toBeNull();
-    expect(normalizedCandidates.has(searchWorkingDir ?? '')).toBe(true);
-  } finally {
-    await repoA.cleanup();
-  }
-});

packages/app/e2e/sidebar-project-filter-flash.spec.ts

@@ -1,117 +0,0 @@
-import { test, expect } from "./fixtures";
-import { gotoHome } from "./helpers/app";
-
-test("project filter dropdown never appears visibly at 0,0 on open", async ({ page }) => {
-  await gotoHome(page);
-
-  const trigger = page.getByText("Project", { exact: true }).first();
-  await expect(trigger).toBeVisible();
-
-  await page.evaluate(() => {
-    (window as any).__projectFilterFlashProbe = new Promise<{
-      targetFound: boolean;
-      visibleAtOrigin: boolean;
-      records: Array<{ left: number; top: number; opacity: number }>;
-    }>((resolve) => {
-      let target: HTMLElement | null = null;
-      const records: Array<{ left: number; top: number; opacity: number }> = [];
-
-      const capture = () => {
-        if (!target) return;
-        const style = getComputedStyle(target);
-        records.push({
-          left: Number.parseFloat(style.left || "0"),
-          top: Number.parseFloat(style.top || "0"),
-          opacity: Number.parseFloat(style.opacity || "1"),
-        });
-      };
-
-      const tryResolveTarget = (root: HTMLElement) => {
-        const stack = [root, ...Array.from(root.querySelectorAll<HTMLElement>("*"))];
-        for (const element of stack) {
-          if (element.dataset?.testid === "combobox-desktop-container") {
-            target = element;
-            return true;
-          }
-        }
-        return false;
-      };
-
-      const finish = () => {
-        observer.disconnect();
-        if (!target) {
-          resolve({
-            targetFound: false,
-            visibleAtOrigin: false,
-            records: [],
-          });
-          return;
-        }
-
-        const visibleAtOrigin = records.some(
-          (entry) => entry.left <= 1 && entry.top <= 1 && entry.opacity > 0.01
-        );
-
-        resolve({
-          targetFound: true,
-          visibleAtOrigin,
-          records,
-        });
-      };
-
-      const sampleFrames = () => {
-        capture();
-        requestAnimationFrame(() => {
-          capture();
-          requestAnimationFrame(() => {
-            capture();
-            requestAnimationFrame(() => {
-              capture();
-              requestAnimationFrame(() => {
-                capture();
-                finish();
-              });
-            });
-          });
-        });
-      };
-
-      const observer = new MutationObserver((mutations) => {
-        for (const mutation of mutations) {
-          for (const added of Array.from(mutation.addedNodes)) {
-            if (!(added instanceof HTMLElement)) continue;
-            if (tryResolveTarget(added)) {
-              sampleFrames();
-              return;
-            }
-          }
-
-          if (
-            mutation.type === "attributes" &&
-            mutation.target instanceof HTMLElement &&
-            !target &&
-            tryResolveTarget(mutation.target)
-          ) {
-            sampleFrames();
-            return;
-          }
-        }
-      });
-
-      observer.observe(document.body, {
-        childList: true,
-        subtree: true,
-        attributes: true,
-        attributeFilter: ["style"],
-      });
-
-      setTimeout(() => finish(), 2500);
-    });
-  });
-
-  await trigger.click();
-  const probe = await page.evaluate(() => (window as any).__projectFilterFlashProbe);
-
-  expect(probe.targetFound).toBe(true);
-  expect(probe.visibleAtOrigin).toBe(false);
-});

packages/app/e2e/sidebar-toggle-tooltip.spec.ts

@@ -1,47 +0,0 @@
-import { test, expect } from './fixtures';
-import { gotoHome, openSettings } from './helpers/app';
-
-test('sidebar toggle shows tooltip on the right', async ({ page }) => {
-  await gotoHome(page);
-  await openSettings(page);
-
-  const menuButton = page.getByRole('button', { name: /menu/i }).first();
-  await expect(menuButton).toBeVisible();
-
-  // Baseline: tooltip should appear on keyboard focus (a11y requirement).
-  await menuButton.focus();
-
-  const tooltip = page.getByTestId('menu-button-tooltip');
-  await expect(tooltip).toBeVisible();
-  await expect(tooltip).toContainText('Toggle sidebar');
-  await expect(tooltip).toContainText(/⌘B|Ctrl\+\./);
-  await page.waitForTimeout(250);
-  await expect(tooltip).toBeVisible();
-
-  // Tooltip should also appear on hover.
-  await menuButton.blur();
-  await expect(tooltip).toHaveCount(0);
-  await menuButton.hover();
-  await expect(tooltip).toBeVisible();
-
-  const triggerBox = await menuButton.boundingBox();
-  const tooltipBox = await tooltip.boundingBox();
-  expect(triggerBox).not.toBeNull();
-  expect(tooltipBox).not.toBeNull();
-  if (!triggerBox || !tooltipBox) return;
-
-  // side=right => tooltip starts to the right of the trigger.
-  expect(tooltipBox.x).toBeGreaterThan(triggerBox.x + triggerBox.width - 1);
-  // Keep it reasonably close (should be ~trigger.right + offset).
-  const expectedX = triggerBox.x + triggerBox.width + 8;
-  expect(Math.abs(tooltipBox.x - expectedX)).toBeLessThanOrEqual(12);
-  expect(tooltipBox.width).toBeGreaterThanOrEqual(60);
-  expect(tooltipBox.width).toBeLessThanOrEqual(500);
-  expect(tooltipBox.height).toBeGreaterThanOrEqual(20);
-  expect(tooltipBox.height).toBeLessThanOrEqual(80);
-
-  // align=center => centers should be roughly aligned (allow some clamping tolerance).
-  const triggerCenterY = triggerBox.y + triggerBox.height / 2;
-  const tooltipCenterY = tooltipBox.y + tooltipBox.height / 2;
-  expect(Math.abs(triggerCenterY - tooltipCenterY)).toBeLessThanOrEqual(24);
-});

packages/app/e2e/terminal-performance.spec.ts

@@ -0,0 +1,165 @@
+import { test, expect } from "./fixtures";
+import { createTempGitRepo } from "./helpers/workspace";
+import {
+  connectTerminalClient,
+  navigateToTerminal,
+  setupDeterministicPrompt,
+  waitForTerminalContent,
+  measureKeystrokeLatency,
+  computePercentile,
+  round2,
+  type TerminalPerfDaemonClient,
+  type LatencySample,
+} from "./helpers/terminal-perf";
+
+const LINE_COUNT = 50_000;
+const THROUGHPUT_BUDGET_MS = 30_000;
+const KEYSTROKE_SAMPLE_COUNT = 20;
+const KEYSTROKE_P95_BUDGET_MS = 150;
+
+test.describe("Terminal wire performance", () => {
+  let client: TerminalPerfDaemonClient;
+  let tempRepo: { path: string; cleanup: () => Promise<void> };
+
+  test.beforeAll(async () => {
+    tempRepo = await createTempGitRepo("perf-");
+    client = await connectTerminalClient();
+  });
+
+  test.afterAll(async () => {
+    if (client) {
+      await client.close();
+    }
+    if (tempRepo) {
+      await tempRepo.cleanup();
+    }
+  });
+
+  test("throughput: bulk terminal output renders within budget", async ({ page }, testInfo) => {
+    test.setTimeout(90_000);
+
+    const result = await client.createTerminal(tempRepo.path, "throughput");
+    if (!result.terminal) {
+      throw new Error(`Failed to create terminal: ${result.error}`);
+    }
+    const terminalId = result.terminal.id;
+
+    try {
+      await navigateToTerminal(page, { cwd: tempRepo.path, terminalId });
+      await setupDeterministicPrompt(page);
+
+      const sentinel = `PERF_DONE_${Date.now()}`;
+      const terminal = page.locator('[data-testid="terminal-surface"]');
+      const startMs = Date.now();
+
+      await terminal.pressSequentially(`seq 1 ${LINE_COUNT}; echo ${sentinel}\n`, { delay: 0 });
+
+      await waitForTerminalContent(
+        page,
+        (text) => text.includes(sentinel),
+        THROUGHPUT_BUDGET_MS + 15_000,
+      );
+
+      const elapsedMs = Date.now() - startMs;
+
+      // seq 1 N outputs each number on its own line
+      const estimatedBytes = Array.from(
+        { length: LINE_COUNT },
+        (_, i) => String(i + 1).length + 1,
+      ).reduce((a, b) => a + b, 0);
+      const throughputMBps = estimatedBytes / (1024 * 1024) / (elapsedMs / 1000);
+
+      const report = {
+        lineCount: LINE_COUNT,
+        estimatedBytes,
+        elapsedMs,
+        throughputMBps: round2(throughputMBps),
+      };
+
+      await testInfo.attach("throughput-report", {
+        body: JSON.stringify(report, null, 2),
+        contentType: "application/json",
+      });
+
+      console.log(
+        `[perf] Throughput: ${report.throughputMBps} MB/s — ${LINE_COUNT} lines in ${elapsedMs}ms`,
+      );
+
+      expect(
+        elapsedMs,
+        `${LINE_COUNT} lines should render within ${THROUGHPUT_BUDGET_MS}ms`,
+      ).toBeLessThan(THROUGHPUT_BUDGET_MS);
+    } finally {
+      await client.killTerminal(terminalId).catch(() => {});
+    }
+  });
+
+  test("keystroke latency: echo round-trip under budget", async ({ page }, testInfo) => {
+    test.setTimeout(60_000);
+
+    const result = await client.createTerminal(tempRepo.path, "latency");
+    if (!result.terminal) {
+      throw new Error(`Failed to create terminal: ${result.error}`);
+    }
+    const terminalId = result.terminal.id;
+
+    try {
+      await navigateToTerminal(page, { cwd: tempRepo.path, terminalId });
+      await setupDeterministicPrompt(page);
+
+      // Ensure clean prompt state
+      const terminal = page.locator('[data-testid="terminal-surface"]');
+      await terminal.press("Control+c");
+      await page.waitForTimeout(200);
+
+      const samples: LatencySample[] = [];
+      const chars = "abcdefghijklmnopqrst";
+
+      for (let i = 0; i < KEYSTROKE_SAMPLE_COUNT; i++) {
+        const char = chars[i % chars.length];
+        const latencyMs = await measureKeystrokeLatency(page, char);
+        samples.push({ char, latencyMs });
+        await page.waitForTimeout(50);
+      }
+
+      // Clean up typed characters
+      await terminal.press("Control+c");
+
+      const latencies = samples.map((s) => s.latencyMs);
+      const p50 = computePercentile(latencies, 50);
+      const p95 = computePercentile(latencies, 95);
+      const max = Math.max(...latencies);
+      const min = Math.min(...latencies);
+      const avg = latencies.reduce((a, b) => a + b, 0) / latencies.length;
+
+      const report = {
+        sampleCount: KEYSTROKE_SAMPLE_COUNT,
+        p50Ms: round2(p50),
+        p95Ms: round2(p95),
+        maxMs: round2(max),
+        minMs: round2(min),
+        avgMs: round2(avg),
+        samples: samples.map((s) => ({
+          char: s.char,
+          latencyMs: round2(s.latencyMs),
+        })),
+      };
+
+      await testInfo.attach("latency-report", {
+        body: JSON.stringify(report, null, 2),
+        contentType: "application/json",
+      });
+
+      console.log(
+        `[perf] Keystroke latency — p50: ${report.p50Ms}ms, p95: ${report.p95Ms}ms, max: ${report.maxMs}ms`,
+      );
+
+      expect(
+        p95,
+        `Keystroke p95 latency should be under ${KEYSTROKE_P95_BUDGET_MS}ms`,
+      ).toBeLessThan(KEYSTROKE_P95_BUDGET_MS);
+    } finally {
+      await client.killTerminal(terminalId).catch(() => {});
+    }
+  });
+});

packages/app/e2e/terminal-responsiveness-benchmark.spec.ts

@@ -1,209 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { test, expect, type Page } from "./fixtures";
-import { setWorkingDirectory } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-import {
-  openNewAgentComposer,
-  seedWorkspaceActivity,
-  switchWorkspaceViaSidebar,
-} from "./helpers/workspace-ui";
-
-function percentile(values: number[], p: number): number {
-  if (values.length === 0) {
-    return 0;
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const rank = Math.ceil((p / 100) * sorted.length);
-  const index = Math.min(sorted.length - 1, Math.max(0, rank - 1));
-  return sorted[index] ?? 0;
-}
-
-function summarize(values: number[]) {
-  if (values.length === 0) {
-    return {
-      count: 0,
-      minMs: 0,
-      maxMs: 0,
-      avgMs: 0,
-      p95Ms: 0,
-      p99Ms: 0,
-    };
-  }
-
-  const sum = values.reduce((acc, value) => acc + value, 0);
-  return {
-    count: values.length,
-    minMs: Math.min(...values),
-    maxMs: Math.max(...values),
-    avgMs: Math.round((sum / values.length) * 100) / 100,
-    p95Ms: percentile(values, 95),
-    p99Ms: percentile(values, 99),
-  };
-}
-
-function buildStressCommand(doneMarker: string): string {
-  // Deterministic synthetic "TUI-like" redraw loop: alternate screen + cursor-home repaint.
-  const markerFile = ".paseo-terminal-benchmark-marker";
-  return [
-    "i=1",
-    "printf '\\033[?1049h\\033[2J'",
-    "while [ $i -le 240 ]; do",
-    "printf '\\033[H'",
-    "r=1",
-    "while [ $r -le 24 ]; do",
-    "printf 'bench frame:%03d row:%02d ########################################\\n' \"$i\" \"$r\"",
-    "r=$((r+1))",
-    "done",
-    "sleep 0.01",
-    "i=$((i+1))",
-    "done",
-    `printf '\\033[?1049l\\n${doneMarker}\\n'`,
-    `printf '${doneMarker}\\n' > '${markerFile}'`,
-  ].join("; ");
-}
-
-async function markerFileContains(filePath: string, marker: string): Promise<boolean> {
-  try {
-    const text = await readFile(filePath, "utf8");
-    return text.includes(marker);
-  } catch {
-    return false;
-  }
-}
-
-async function toggleExplorerAndMeasureLatency(page: Page): Promise<number> {
-  const toggle = page.getByTestId("workspace-explorer-toggle").first();
-  await expect(toggle).toBeVisible({ timeout: 30_000 });
-  const currentlyExpanded = (await toggle.getAttribute("aria-expanded")) === "true";
-  const expected = currentlyExpanded ? "false" : "true";
-
-  const start = Date.now();
-  await toggle.click();
-  await expect(toggle).toHaveAttribute("aria-expanded", expected, { timeout: 15_000 });
-  return Date.now() - start;
-}
-
-test("workspace terminal responsiveness benchmark (report-only, single stress profile)", async ({
-  page,
-}, testInfo) => {
-  test.setTimeout(180_000);
-  const repo = await createTempGitRepo("paseo-e2e-terminal-benchmark-");
-  const markerFilePath = path.join(repo.path, ".paseo-terminal-benchmark-marker");
-
-  try {
-    const serverId = process.env.E2E_SERVER_ID;
-    if (!serverId) {
-      throw new Error("E2E_SERVER_ID is not set.");
-    }
-
-    await openNewAgentComposer(page);
-    await setWorkingDirectory(page, repo.path);
-    await seedWorkspaceActivity(page, `terminal benchmark seed ${Date.now()}`);
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repo.path });
-    await expect(page.getByTestId("workspace-new-terminal-tab").first()).toBeVisible({
-      timeout: 30_000,
-    });
-
-    const newTerminalButton = page.getByTestId("workspace-new-terminal-tab").first();
-    await expect(newTerminalButton).toBeVisible({ timeout: 30_000 });
-    await newTerminalButton.click();
-
-    const surface = page.locator('[data-testid="terminal-surface"]:visible').first();
-    await expect(surface).toBeVisible({ timeout: 60_000 });
-    await surface.click({ force: true });
-
-    await page.evaluate(() => {
-      const monitor = {
-        samples: [] as number[],
-        active: true,
-        rafId: 0,
-        lastTs: performance.now(),
-      };
-
-      const tick = (ts: number) => {
-        if (!monitor.active) {
-          return;
-        }
-        monitor.samples.push(ts - monitor.lastTs);
-        monitor.lastTs = ts;
-        monitor.rafId = requestAnimationFrame(tick);
-      };
-
-      monitor.rafId = requestAnimationFrame(tick);
-
-      (window as { __PASEO_E2E_RAF_MONITOR__?: { stop: () => { samples: number[] } } }).__PASEO_E2E_RAF_MONITOR__ =
-        {
-          stop: () => {
-            if (!monitor.active) {
-              return { samples: monitor.samples };
-            }
-            monitor.active = false;
-            cancelAnimationFrame(monitor.rafId);
-            return { samples: monitor.samples };
-          },
-        };
-    });
-
-    const doneMarker = `TERMINAL_BENCH_DONE_${Date.now()}`;
-    const postMarker = `TERMINAL_BENCH_POST_${Date.now()}`;
-    const stressCommand = buildStressCommand(doneMarker);
-    await page.keyboard.type(stressCommand, { delay: 0 });
-    await page.keyboard.press("Enter");
-
-    const interactionLatenciesMs: number[] = [];
-    for (let attempt = 0; attempt < 18; attempt += 1) {
-      const latency = await toggleExplorerAndMeasureLatency(page);
-      interactionLatenciesMs.push(latency);
-    }
-
-    const rafResult = await page.evaluate(() => {
-      const handle = (
-        window as { __PASEO_E2E_RAF_MONITOR__?: { stop: () => { samples: number[] } } }
-      ).__PASEO_E2E_RAF_MONITOR__;
-      if (!handle || typeof handle.stop !== "function") {
-        return { samples: [] as number[] };
-      }
-      return handle.stop();
-    });
-
-    await surface.click({ force: true });
-    await page.keyboard.type(`echo ${postMarker} >> .paseo-terminal-benchmark-marker`, { delay: 0 });
-    await page.keyboard.press("Enter");
-    await expect.poll(async () => await markerFileContains(markerFilePath, postMarker), {
-      timeout: 120_000,
-    }).toBe(true);
-
-    const frameGapsMs = (rafResult.samples ?? []).filter(
-      (sample) => Number.isFinite(sample) && sample > 0
-    );
-    const report = {
-      mode: "report-only",
-      profile: "single-stress",
-      generatedAt: new Date().toISOString(),
-      workload: {
-        frames: 240,
-        rowsPerFrame: 24,
-        frameSleepMs: 10,
-        doneMarker,
-        postMarker,
-        doneMarkerObserved: await markerFileContains(markerFilePath, doneMarker),
-      },
-      frameGapMs: {
-        ...summarize(frameGapsMs),
-        over100Ms: frameGapsMs.filter((gap) => gap > 100).length,
-        over250Ms: frameGapsMs.filter((gap) => gap > 250).length,
-        over500Ms: frameGapsMs.filter((gap) => gap > 500).length,
-      },
-      explorerToggleLatencyMs: summarize(interactionLatenciesMs),
-    };
-
-    await testInfo.attach("terminal-responsiveness-report", {
-      body: JSON.stringify(report, null, 2),
-      contentType: "application/json",
-    });
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/working-directory-combobox-positioning.spec.ts

@@ -1,158 +0,0 @@
-import { expect, test } from "./fixtures";
-import { gotoHome } from "./helpers/app";
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-test("working directory combobox stays visually stable while typing search", async ({ page }) => {
-  await gotoHome(page);
-
-  const workingDirectorySelect = page
-    .locator('[data-testid="working-directory-select"]:visible')
-    .first();
-  await expect(workingDirectorySelect).toBeVisible();
-  await workingDirectorySelect.click({ force: true });
-
-  const searchInput = page.getByRole("textbox", { name: /search directories/i }).first();
-  await expect(searchInput).toBeVisible();
-
-  await page.evaluate(() => {
-    const trigger = document.querySelector('[data-testid="working-directory-select"]');
-    const searchInput = document.querySelector('input[placeholder="Search directories..."]');
-    const container = document.querySelector('[data-testid="combobox-desktop-container"]');
-    if (!(trigger instanceof HTMLElement)) {
-      throw new Error("Missing working-directory-select trigger.");
-    }
-    if (!(searchInput instanceof HTMLInputElement)) {
-      throw new Error("Missing working directory search input.");
-    }
-    if (!(container instanceof HTMLElement)) {
-      throw new Error("Missing combobox desktop container.");
-    }
-
-    const state = {
-      samples: 0,
-      underTriggerSamples: 0,
-      emptyWhileSearchingSamples: 0,
-      minSearchDelta: Number.POSITIVE_INFINITY,
-      maxSearchDelta: Number.NEGATIVE_INFINITY,
-      minContainerDelta: Number.POSITIVE_INFINITY,
-      maxContainerDelta: Number.NEGATIVE_INFINITY,
-      logs: [] as Array<{
-        reason: string;
-        query: string;
-        searchDelta: number;
-        containerDelta: number;
-        hasEmpty: boolean;
-        containerTop: number;
-        containerBottom: number;
-        triggerTop: number;
-        searchBottom: number;
-      }>,
-    };
-
-    const sample = (reason: string) => {
-      if (!document.body.contains(trigger) || !document.body.contains(searchInput) || !document.body.contains(container)) {
-        return;
-      }
-      const query = searchInput.value.trim();
-      if (!query) {
-        return;
-      }
-
-      const triggerRect = trigger.getBoundingClientRect();
-      const searchRect = searchInput.getBoundingClientRect();
-      const containerRect = container.getBoundingClientRect();
-      const hasEmpty = Boolean(container.querySelector('[data-testid="combobox-empty-text"]'));
-      const searchDelta = searchRect.bottom - triggerRect.top;
-      const containerDelta = containerRect.bottom - triggerRect.top;
-
-      state.samples += 1;
-      state.minSearchDelta = Math.min(state.minSearchDelta, searchDelta);
-      state.maxSearchDelta = Math.max(state.maxSearchDelta, searchDelta);
-      state.minContainerDelta = Math.min(state.minContainerDelta, containerDelta);
-      state.maxContainerDelta = Math.max(state.maxContainerDelta, containerDelta);
-      if (searchDelta > 2 || containerDelta > 2) {
-        state.underTriggerSamples += 1;
-      }
-      if (hasEmpty) {
-        state.emptyWhileSearchingSamples += 1;
-      }
-      if (state.logs.length < 80) {
-        state.logs.push({
-          reason,
-          query,
-          searchDelta,
-          containerDelta,
-          hasEmpty,
-          containerTop: containerRect.top,
-          containerBottom: containerRect.bottom,
-          triggerTop: triggerRect.top,
-          searchBottom: searchRect.bottom,
-        });
-      }
-    };
-
-    const mutationObserver = new MutationObserver(() => sample("mutation"));
-    mutationObserver.observe(container, {
-      childList: true,
-      subtree: true,
-      attributes: true,
-      characterData: true,
-    });
-
-    const resizeObserver = new ResizeObserver(() => sample("resize"));
-    resizeObserver.observe(container);
-    resizeObserver.observe(searchInput);
-
-    let rafId = 0;
-    const loop = () => {
-      sample("raf");
-      rafId = requestAnimationFrame(loop);
-    };
-    rafId = requestAnimationFrame(loop);
-
-    (window as any).__paseoComboboxObserver = {
-      stop: () => {
-        cancelAnimationFrame(rafId);
-        mutationObserver.disconnect();
-        resizeObserver.disconnect();
-        sample("stop");
-        return {
-          ...state,
-          minSearchDelta: state.samples > 0 ? state.minSearchDelta : 0,
-          maxSearchDelta: state.samples > 0 ? state.maxSearchDelta : 0,
-          minContainerDelta: state.samples > 0 ? state.minContainerDelta : 0,
-          maxContainerDelta: state.samples > 0 ? state.maxContainerDelta : 0,
-        };
-      },
-    };
-  });
-
-  const queries = [
-    "/tmp/paseo-stability-a",
-    "/tmp/paseo-stability-ab",
-    "/tmp/paseo-stability-abc",
-    "/tmp/paseo-stability-longer-branch",
-    "/tmp/paseo-stability-z",
-  ];
-
-  for (const query of queries) {
-    await searchInput.fill("");
-    await searchInput.type(query, { delay: 20 });
-    const customOption = page.getByText(new RegExp(`^${escapeRegex(query)}$`)).first();
-    await expect(customOption).toBeVisible();
-    await page.waitForTimeout(100);
-  }
-
-  const stats = await page.evaluate(() => (window as any).__paseoComboboxObserver.stop());
-  const debug = JSON.stringify(stats.logs.slice(-10));
-
-  expect(stats.samples, debug).toBeGreaterThan(20);
-  expect(stats.underTriggerSamples, debug).toBe(0);
-  expect(stats.emptyWhileSearchingSamples, debug).toBe(0);
-  expect(stats.maxSearchDelta - stats.minSearchDelta, debug).toBeLessThanOrEqual(3);
-  expect(stats.maxContainerDelta - stats.minContainerDelta, debug).toBeLessThanOrEqual(3);
-  expect(stats.maxContainerDelta, debug).toBeLessThanOrEqual(2);
-});

packages/app/e2e/workspace-draft-create-status-controls.spec.ts

@@ -1,107 +0,0 @@
-import { test, expect } from './fixtures'
-import { ensureHostSelected, gotoHome, setWorkingDirectory } from './helpers/app'
-import { createTempGitRepo } from './helpers/workspace'
-import {
-  ensureWorkspaceAgentPaneVisible,
-  getWorkspaceTabTestIds,
-  waitForWorkspaceTabsVisible,
-} from './helpers/workspace-tabs'
-import { switchWorkspaceViaSidebar } from './helpers/workspace-ui'
-
-function escapeRegex(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-}
-
-test('workspace draft tab uses input status controls with optimistic create and in-place transition', async ({
-  page,
-}) => {
-  const serverId = process.env.E2E_SERVER_ID
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set.')
-  }
-
-  const repo = await createTempGitRepo('paseo-e2e-workspace-draft-')
-  const seedPrompt = `seed workspace ${Date.now()}`
-  const createPrompt = `workspace draft prompt ${Date.now()}`
-
-  try {
-    await gotoHome(page)
-    await ensureHostSelected(page)
-
-    // Force the setup onto the global draft surface. In slow runs the app can
-    // still be on a previously opened agent/workspace view where the placement
-    // form is not rendered.
-    await page.goto(`/h/${serverId}/new-agent`)
-    await expect(page.locator('[data-testid="working-directory-select"]:visible').first()).toBeVisible({
-      timeout: 30_000,
-    })
-
-    await setWorkingDirectory(page, repo.path)
-    const seedComposer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await seedComposer.fill(seedPrompt)
-    await page.getByRole('button', { name: /send message/i }).first().click()
-    await expect(page.getByText(seedPrompt, { exact: true }).first()).toBeVisible({
-      timeout: 30_000,
-    })
-    await expect(page).toHaveURL(/\/workspace\//, { timeout: 60_000 })
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repo.path })
-    const workspaceRouteToken = page.url().match(/\/workspace\/([^/?#]+)/)?.[1] ?? null
-    expect(workspaceRouteToken).toBeTruthy()
-    await waitForWorkspaceTabsVisible(page)
-    await ensureWorkspaceAgentPaneVisible(page)
-
-    const beforeDraftIds = await getWorkspaceTabTestIds(page)
-    await page.getByTestId('workspace-new-agent-tab').first().click()
-    await ensureWorkspaceAgentPaneVisible(page)
-
-    const withDraftIds = await getWorkspaceTabTestIds(page)
-    const draftTabTestId = withDraftIds.find((id) => !beforeDraftIds.includes(id))
-    if (!draftTabTestId) {
-      throw new Error('Expected a draft workspace tab to be created.')
-    }
-
-    const draftId = draftTabTestId.replace('workspace-tab-', '')
-    const draftCloseButton = page.getByTestId(`workspace-draft-close-${draftId}`).first()
-    await expect(draftCloseButton).toBeVisible({ timeout: 30_000 })
-
-    await expect(page.getByTestId('working-directory-select').first()).not.toBeVisible()
-    await expect(page.getByTestId('worktree-select-trigger').first()).not.toBeVisible()
-
-    const providerSelector = page.getByTestId('agent-provider-selector').first()
-    const modeSelector = page.getByTestId('agent-mode-selector').first()
-    const modelSelector = page.getByTestId('agent-model-selector').first()
-    const thinkingSelector = page.getByTestId('agent-thinking-selector').first()
-
-    await expect(providerSelector).toBeVisible({ timeout: 30_000 })
-    await expect(modeSelector).toBeVisible({ timeout: 30_000 })
-    await expect(modelSelector).toBeVisible({ timeout: 30_000 })
-    await expect(thinkingSelector).toBeVisible({ timeout: 30_000 })
-
-    const selectedMode = ((await modeSelector.innerText()) ?? '').trim()
-    const selectedModel = ((await modelSelector.innerText()) ?? '').trim()
-    const selectedThinking = ((await thinkingSelector.innerText()) ?? '').trim()
-
-    const composer = page.getByRole('textbox', { name: 'Message agent...' }).first()
-    await composer.fill(createPrompt)
-    await composer.press('Enter')
-
-    await expect(page.getByText(createPrompt, { exact: true }).first()).toBeVisible({ timeout: 5_000 })
-    await expect(draftCloseButton).not.toBeVisible({ timeout: 30_000 })
-
-    const finalIds = await getWorkspaceTabTestIds(page)
-    expect(finalIds).toContain(draftTabTestId)
-
-    await expect(modelSelector).toContainText(new RegExp(escapeRegex(selectedModel), 'i'))
-    await expect(modeSelector).toContainText(new RegExp(escapeRegex(selectedMode), 'i'))
-    await expect(thinkingSelector).toContainText(new RegExp(escapeRegex(selectedThinking), 'i'))
-
-    const currentUrl = page.url()
-    if (!workspaceRouteToken) {
-      throw new Error('Expected workspace route token to be present.')
-    }
-    expect(currentUrl).toContain(`/workspace/${workspaceRouteToken}`)
-  } finally {
-    await repo.cleanup()
-  }
-})

packages/app/e2e/workspace-draft-tab-retarget.spec.ts

@@ -1,125 +0,0 @@
-import { test, expect } from "./fixtures";
-import type { Page } from "@playwright/test";
-import { createAgentInRepo } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-import {
-  ensureWorkspaceAgentPaneVisible,
-  getWorkspaceTabTestIds,
-  sampleWorkspaceTabIds,
-  waitForWorkspaceTabsVisible,
-} from "./helpers/workspace-tabs";
-import { switchWorkspaceViaSidebar } from "./helpers/workspace-ui";
-
-async function expectComposerFocused(page: Page) {
-  const composer = page.getByRole("textbox", { name: "Message agent..." }).first();
-  await expect(composer).toBeEditable({ timeout: 30_000 });
-  await expect
-    .poll(async () => {
-      return await composer.evaluate(
-        (element) => document.activeElement === element
-      );
-    })
-    .toBe(true);
-}
-
-test("workspace draft submit retargets tab in place without transient extra tabs", async ({ page }) => {
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!serverId) {
-    throw new Error("E2E_SERVER_ID is not set.");
-  }
-
-  const repo = await createTempGitRepo("paseo-e2e-draft-retarget-");
-  const seedPrompt = `seed prompt ${Date.now()}`;
-  const createPrompt = `retarget prompt ${Date.now()}`;
-
-  try {
-    await createAgentInRepo(page, { directory: repo.path, prompt: seedPrompt });
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repo.path });
-    await waitForWorkspaceTabsVisible(page);
-    await ensureWorkspaceAgentPaneVisible(page);
-
-    const beforeDraftIds = await getWorkspaceTabTestIds(page);
-    await page.getByTestId("workspace-new-agent-tab").first().click();
-    await ensureWorkspaceAgentPaneVisible(page);
-    await expect(page.getByRole("textbox", { name: "Message agent..." })).toBeEditable();
-
-    const withDraftIds = await getWorkspaceTabTestIds(page);
-    expect(withDraftIds.length).toBe(beforeDraftIds.length + 1);
-    const draftTabTestId = withDraftIds.find((id) => !beforeDraftIds.includes(id));
-    expect(draftTabTestId).toBeTruthy();
-
-    const draftId = draftTabTestId!.replace("workspace-tab-", "");
-    const draftCloseButton = page.getByTestId(`workspace-draft-close-${draftId}`).first();
-    await expect(draftCloseButton).toBeVisible({ timeout: 30_000 });
-
-    const samplingPromise = sampleWorkspaceTabIds(page, { durationMs: 3_000, intervalMs: 40 });
-    const input = page.getByRole("textbox", { name: "Message agent..." });
-    await input.fill(createPrompt);
-    await input.press("Enter");
-    await expect(page.getByText(createPrompt, { exact: true }).first()).toBeVisible({
-      timeout: 30_000,
-    });
-
-    const snapshots = await samplingPromise;
-    const maxObservedCount = snapshots.reduce((max, ids) => Math.max(max, ids.length), 0);
-    expect(maxObservedCount).toBe(withDraftIds.length);
-
-    const finalIds = await getWorkspaceTabTestIds(page);
-    expect(finalIds.length).toBe(withDraftIds.length);
-    expect(finalIds).toContain(draftTabTestId!);
-    await expect(draftCloseButton).not.toBeVisible({ timeout: 30_000 });
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test("workspace agent tab switch focuses composer on desktop web", async ({ page }) => {
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!serverId) {
-    throw new Error("E2E_SERVER_ID is not set.");
-  }
-
-  const repo = await createTempGitRepo("paseo-e2e-tab-focus-");
-  const firstPrompt = `first tab prompt ${Date.now()}`;
-  const secondPrompt = `second tab prompt ${Date.now()}`;
-
-  try {
-    await createAgentInRepo(page, { directory: repo.path, prompt: firstPrompt });
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repo.path });
-    await waitForWorkspaceTabsVisible(page);
-    await ensureWorkspaceAgentPaneVisible(page);
-
-    const beforeSecondAgentIds = await getWorkspaceTabTestIds(page);
-    await page.getByTestId("workspace-new-agent-tab").first().click();
-    await expectComposerFocused(page);
-
-    const composer = page.getByRole("textbox", { name: "Message agent..." }).first();
-    await composer.fill(secondPrompt);
-    await composer.press("Enter");
-    await expect(page.getByText(secondPrompt, { exact: true }).first()).toBeVisible({
-      timeout: 30_000,
-    });
-
-    const withSecondAgentIds = await getWorkspaceTabTestIds(page);
-    const secondAgentTabTestId = withSecondAgentIds.find(
-      (id) => !beforeSecondAgentIds.includes(id)
-    );
-    if (!secondAgentTabTestId) {
-      throw new Error("Expected second agent tab to be created.");
-    }
-
-    const firstAgentTabTestId = beforeSecondAgentIds[0];
-    if (!firstAgentTabTestId) {
-      throw new Error("Expected first agent tab to exist.");
-    }
-
-    await page.getByTestId(firstAgentTabTestId).first().click();
-    await expectComposerFocused(page);
-
-    await page.getByTestId(secondAgentTabTestId).first().click();
-    await expectComposerFocused(page);
-  } finally {
-    await repo.cleanup();
-  }
-});

packages/app/e2e/workspace-header-tabs-restore.spec.ts

@@ -1,165 +0,0 @@
-import { test, expect, type Page } from "./fixtures";
-import { createAgentInRepo } from "./helpers/app";
-import { createTempGitRepo } from "./helpers/workspace";
-import { switchWorkspaceViaSidebar } from "./helpers/workspace-ui";
-
-async function openWorkspaceWithAgent(page: Page, workspacePath: string): Promise<void> {
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!serverId) {
-    throw new Error("E2E_SERVER_ID is not set.");
-  }
-
-  await createAgentInRepo(page, {
-    directory: workspacePath,
-    prompt: `workspace header restore ${Date.now()}`,
-  });
-  await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: workspacePath });
-  await expect(page.getByTestId("workspace-new-agent-tab").first()).toBeVisible({
-    timeout: 30000,
-  });
-  await expect(page.getByTestId("workspace-new-terminal-tab").first()).toBeVisible({
-    timeout: 30000,
-  });
-}
-
-test("workspace new-tab buttons stay on-screen during horizontal scroll", async ({ page }) => {
-  const repo = await createTempGitRepo("paseo-e2e-workspace-new-tab-");
-
-  try {
-    await openWorkspaceWithAgent(page, repo.path);
-
-    const agentButton = page.getByTestId("workspace-new-agent-tab").first();
-    const terminalButton = page.getByTestId("workspace-new-terminal-tab").first();
-    const tabsScroll = page.getByTestId("workspace-tabs-scroll").first();
-    await expect(agentButton).toBeVisible({ timeout: 30000 });
-    await expect(terminalButton).toBeVisible({ timeout: 30000 });
-    await expect(tabsScroll).toBeVisible({ timeout: 30000 });
-
-    // Create enough terminal tabs to ensure the tabs row has overflow to scroll.
-    const workspaceTabs = page.locator(
-      '[data-testid^="workspace-tab-"]:not([data-testid^="workspace-tab-context-"])'
-    );
-    const initialTabCount = await workspaceTabs.count();
-    const targetTabCount = initialTabCount + 8;
-
-    for (let attempt = initialTabCount; attempt < targetTabCount; attempt += 1) {
-      await expect(terminalButton).toBeEnabled({ timeout: 30000 });
-      await terminalButton.click();
-      await expect
-        .poll(async () => await workspaceTabs.count(), { timeout: 30000 })
-        .toBeGreaterThanOrEqual(attempt + 1);
-    }
-
-    const agentBoundsBefore = await agentButton.boundingBox();
-    const terminalBoundsBefore = await terminalButton.boundingBox();
-    const viewport = page.viewportSize();
-
-    expect(agentBoundsBefore).not.toBeNull();
-    expect(terminalBoundsBefore).not.toBeNull();
-    expect(viewport).not.toBeNull();
-
-    if (!agentBoundsBefore || !terminalBoundsBefore || !viewport) {
-      return;
-    }
-
-    expect(agentBoundsBefore.x).toBeGreaterThanOrEqual(0);
-    expect(agentBoundsBefore.y).toBeGreaterThanOrEqual(0);
-    expect(agentBoundsBefore.x + agentBoundsBefore.width).toBeLessThanOrEqual(viewport.width);
-    expect(agentBoundsBefore.y + agentBoundsBefore.height).toBeLessThanOrEqual(viewport.height);
-
-    expect(terminalBoundsBefore.x).toBeGreaterThanOrEqual(0);
-    expect(terminalBoundsBefore.y).toBeGreaterThanOrEqual(0);
-    expect(terminalBoundsBefore.x + terminalBoundsBefore.width).toBeLessThanOrEqual(viewport.width);
-    expect(terminalBoundsBefore.y + terminalBoundsBefore.height).toBeLessThanOrEqual(viewport.height);
-
-    // Scroll tabs horizontally; the new-tab buttons should remain fixed on the right edge.
-    await tabsScroll.evaluate((el) => {
-      (el as HTMLElement).scrollLeft = (el as HTMLElement).scrollWidth;
-    });
-    await page.waitForTimeout(200);
-
-    const agentBoundsAfter = await agentButton.boundingBox();
-    const terminalBoundsAfter = await terminalButton.boundingBox();
-
-    expect(agentBoundsAfter).not.toBeNull();
-    expect(terminalBoundsAfter).not.toBeNull();
-
-    if (!agentBoundsAfter || !terminalBoundsAfter) {
-      return;
-    }
-
-    expect(agentBoundsAfter.x).toBeGreaterThanOrEqual(0);
-    expect(agentBoundsAfter.y).toBeGreaterThanOrEqual(0);
-    expect(agentBoundsAfter.x + agentBoundsAfter.width).toBeLessThanOrEqual(viewport.width);
-    expect(agentBoundsAfter.y + agentBoundsAfter.height).toBeLessThanOrEqual(viewport.height);
-
-    expect(terminalBoundsAfter.x).toBeGreaterThanOrEqual(0);
-    expect(terminalBoundsAfter.y).toBeGreaterThanOrEqual(0);
-    expect(terminalBoundsAfter.x + terminalBoundsAfter.width).toBeLessThanOrEqual(viewport.width);
-    expect(terminalBoundsAfter.y + terminalBoundsAfter.height).toBeLessThanOrEqual(viewport.height);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test("workspace new-tab buttons sit immediately after tabs before overflow", async ({ page }) => {
-  const repo = await createTempGitRepo("paseo-e2e-workspace-new-tab-adjacent-");
-
-  try {
-    await openWorkspaceWithAgent(page, repo.path);
-
-    const agentButton = page.getByTestId("workspace-new-agent-tab").first();
-    const workspaceTabs = page.locator(
-      '[data-testid^="workspace-tab-"]:not([data-testid^="workspace-tab-context-"])'
-    );
-
-    await expect(agentButton).toBeVisible({ timeout: 30000 });
-    await expect(workspaceTabs).toHaveCount(1, { timeout: 30000 });
-
-    const lastTabBounds = await workspaceTabs.last().boundingBox();
-    const agentBounds = await agentButton.boundingBox();
-
-    expect(lastTabBounds).not.toBeNull();
-    expect(agentBounds).not.toBeNull();
-
-    if (!lastTabBounds || !agentBounds) {
-      return;
-    }
-
-    const horizontalGap = agentBounds.x - (lastTabBounds.x + lastTabBounds.width);
-
-    expect(horizontalGap).toBeGreaterThanOrEqual(0);
-    expect(horizontalGap).toBeLessThanOrEqual(24);
-  } finally {
-    await repo.cleanup();
-  }
-});
-
-test("workspace explorer toggle opens and closes explorer", async ({ page }) => {
-  const repo = await createTempGitRepo("paseo-e2e-workspace-explorer-toggle-");
-
-  try {
-    await openWorkspaceWithAgent(page, repo.path);
-
-    const toggle = page.getByTestId("workspace-explorer-toggle").first();
-    const explorerHeader = page.locator('[data-testid="explorer-header"]:visible').first();
-    await expect(toggle).toBeVisible({ timeout: 30000 });
-
-    const initiallyExpanded = (await toggle.getAttribute("aria-expanded")) === "true";
-    if (initiallyExpanded) {
-      await toggle.click();
-      await expect(toggle).toHaveAttribute("aria-expanded", "false");
-      await expect(explorerHeader).not.toBeVisible({ timeout: 10000 });
-    }
-
-    await toggle.click();
-    await expect(toggle).toHaveAttribute("aria-expanded", "true");
-    await expect(explorerHeader).toBeVisible({ timeout: 10000 });
-
-    await toggle.click();
-    await expect(toggle).toHaveAttribute("aria-expanded", "false");
-    await expect(explorerHeader).not.toBeVisible({ timeout: 10000 });
-  } finally {
-    await repo.cleanup();
-  }
-});

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

@@ -1,58 +0,0 @@
-import { execSync } from 'node:child_process';
-import { test } from './fixtures';
-import { setWorkingDirectory } from './helpers/app';
-import { createTempGitRepo } from './helpers/workspace';
-import {
-  expectWorkspaceHeader,
-  openNewAgentComposer,
-  seedWorkspaceActivity,
-  switchWorkspaceViaSidebar,
-  workspaceLabelFromPath,
-} from './helpers/workspace-ui';
-
-test('sidebar workspace switch keeps visible content in sync with selected workspace', async ({ page }) => {
-  const serverId = process.env.E2E_SERVER_ID;
-  if (!serverId) {
-    throw new Error('E2E_SERVER_ID is not set.');
-  }
-
-  const repoA = await createTempGitRepo('paseo-e2e-sync-a-');
-  const repoB = await createTempGitRepo('paseo-e2e-sync-b-');
-
-  const tokenA = `SYNC_A_${Date.now()}`;
-  const tokenB = `SYNC_B_${Date.now()}`;
-
-  try {
-    execSync('git checkout -b sync-a-branch', { cwd: repoA.path, stdio: 'ignore' });
-    execSync('git checkout -b sync-b-branch', { cwd: repoB.path, stdio: 'ignore' });
-
-    await openNewAgentComposer(page);
-    await setWorkingDirectory(page, repoA.path);
-    await seedWorkspaceActivity(page, tokenA);
-
-    await openNewAgentComposer(page);
-    await setWorkingDirectory(page, repoB.path);
-    await seedWorkspaceActivity(page, tokenB);
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repoA.path });
-    await expectWorkspaceHeader(page, {
-      title: 'sync-a-branch',
-      subtitle: workspaceLabelFromPath(repoA.path),
-    });
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repoB.path });
-    await expectWorkspaceHeader(page, {
-      title: 'sync-b-branch',
-      subtitle: workspaceLabelFromPath(repoB.path),
-    });
-
-    await switchWorkspaceViaSidebar({ page, serverId, targetWorkspacePath: repoA.path });
-    await expectWorkspaceHeader(page, {
-      title: 'sync-a-branch',
-      subtitle: workspaceLabelFromPath(repoA.path),
-    });
-  } finally {
-    await repoA.cleanup();
-    await repoB.cleanup();
-  }
-});

packages/app/eslint.config.js

@@ -1,10 +1,10 @@
 // https://docs.expo.dev/guides/using-eslint/
-const { defineConfig } = require('eslint/config');
-const expoConfig = require('eslint-config-expo/flat');
+const { defineConfig } = require("eslint/config");
+const expoConfig = require("eslint-config-expo/flat");
 
 module.exports = defineConfig([
   expoConfig,
   {
-    ignores: ['dist/*'],
+    ignores: ["dist/*"],
   },
 ]);

packages/app/index.ts

@@ -2,17 +2,10 @@
 import { polyfillCrypto } from "./src/polyfills/crypto";
 polyfillCrypto();
 
-// Polyfill screen.orientation for WebKitGTK (Tauri Linux) which lacks the API
+// Polyfill screen.orientation for WebKitGTK desktop runtimes that lack the API.
 import { polyfillScreenOrientation } from "./src/polyfills/screen-orientation";
 polyfillScreenOrientation();
 
-// Bridge console.log/warn/error to Tauri's log plugin so JS output appears in app.log
-if ((globalThis as { __TAURI__?: unknown }).__TAURI__) {
-  import("@tauri-apps/plugin-log").then(({ attachConsole }) => {
-    attachConsole();
-  });
-}
-
 // Configure Unistyles before Expo Router pulls in any components using StyleSheet.
 import "./src/styles/unistyles";
 import "expo-router/entry";

packages/app/maestro/.gitignore

@@ -0,0 +1,2 @@
+# Maestro takeScreenshot artifacts
+*.png

packages/app/maestro/sidebar-theme-repro.yaml

@@ -0,0 +1,31 @@
+appId: sh.paseo
+---
+# Ensure sidebar is closed: if sidebar-sessions is visible, close it via swipe left
+- runFlow:
+    when:
+      visible:
+        id: "sidebar-sessions"
+    commands:
+      - swipe:
+          direction: LEFT
+          duration: 300
+
+# Small pause for close animation
+- takeScreenshot: 00-sidebar-closed
+
+# Open sidebar via swipe right gesture (the actual path that triggers the bug)
+- swipe:
+    start: "5%,50%"
+    end: "80%,50%"
+    duration: 300
+
+# Verify sidebar opened
+- assertVisible:
+    id: "sidebar-sessions"
+- takeScreenshot: 01-sidebar-opened
+
+# Close sidebar via swipe left
+- swipe:
+    direction: LEFT
+    duration: 300
+- takeScreenshot: 02-sidebar-closed-again

packages/app/maestro/test-sidebar-theme.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Verification loop for sidebar theme bug.
+#
+# Maestro can't toggle iOS appearance, so this script bridges the gap:
+# toggle appearance via xcrun simctl, then run Maestro to verify the sidebar
+# still works. Runs N iterations to catch intermittent failures.
+#
+# Usage:
+#   bash packages/app/maestro/test-sidebar-theme.sh [iterations] [wait_seconds]
+#   bash packages/app/maestro/test-sidebar-theme.sh 6 1
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+FLOW="$REPO_ROOT/packages/app/maestro/sidebar-theme-repro.yaml"
+OUT_DIR="/tmp/sidebar-theme-test-$(date +%s)"
+ITERATIONS="${1:-3}"
+WAIT_SECS="${2:-1}"
+mkdir -p "$OUT_DIR"
+
+echo "=== Sidebar Theme Bug Verification ==="
+echo "Output dir: $OUT_DIR"
+echo "Iterations: $ITERATIONS, wait after toggle: ${WAIT_SECS}s"
+
+FAILURES=0
+
+for i in $(seq 1 "$ITERATIONS"); do
+  echo ""
+  echo "========== Iteration $i / $ITERATIONS =========="
+
+  CURRENT=$(xcrun simctl ui booted appearance 2>&1 | tr -d '[:space:]')
+  echo "Current appearance: $CURRENT"
+
+  if [ "$CURRENT" = "dark" ]; then
+    xcrun simctl ui booted appearance light
+    echo "Switched to light mode"
+  else
+    xcrun simctl ui booted appearance dark
+    echo "Switched to dark mode"
+  fi
+
+  echo "Waiting ${WAIT_SECS}s..."
+  sleep "$WAIT_SECS"
+
+  ITER_DIR="$OUT_DIR/iter-$i"
+  mkdir -p "$ITER_DIR"
+
+  # Run maestro from the output dir so takeScreenshot artifacts land there
+  if (cd "$ITER_DIR" && maestro test "$FLOW") 2>&1 | tee "$ITER_DIR/test.log"; then
+    echo "  -> PASS (iteration $i)"
+  else
+    echo "  -> FAIL (iteration $i) — bug reproduced!"
+    FAILURES=$((FAILURES + 1))
+    xcrun simctl io booted screenshot "$ITER_DIR/failure-state.png" 2>/dev/null || true
+  fi
+done
+
+# Restore to dark mode
+xcrun simctl ui booted appearance dark
+
+echo ""
+echo "=== Summary: $FAILURES failures out of $ITERATIONS iterations ==="
+echo "Output: $OUT_DIR"

packages/app/package.json

@@ -1,49 +1,41 @@
 {
   "name": "@getpaseo/app",
   "main": "index.ts",
-  "version": "0.1.27",
+  "version": "0.1.53",
   "private": true,
   "scripts": {
     "start": "expo start",
     "reset-project": "node ./scripts/reset-project.js",
+    "build:workspace-deps": "npm run build --workspace=@getpaseo/highlight && npm run build --workspace=@getpaseo/expo-two-way-audio",
+    "eas-build-post-install": "npm run build:workspace-deps",
     "android": "npm run android:development",
-    "android:clear-autolinking-cache": "node -e \"require('node:fs').rmSync('android/build/generated/autolinking', { recursive: true, force: true })\"",
-    "android:development": "npm run android:clear-autolinking-cache && APP_VARIANT=development expo prebuild --platform android --non-interactive && APP_VARIANT=development expo run:android --variant=debug",
-    "android:production": "npm run android:clear-autolinking-cache && APP_VARIANT=production expo prebuild --platform android --non-interactive && APP_VARIANT=production expo run:android --variant=release",
+    "android:development": "APP_VARIANT=development expo prebuild --platform android --non-interactive && APP_VARIANT=development expo run:android --variant=debug",
+    "android:production": "APP_VARIANT=production expo prebuild --platform android --non-interactive && APP_VARIANT=production expo run:android --variant=release",
     "android:release": "npm run android:production",
-    "android:clean": "expo prebuild --platform android --clean --non-interactive",
+    "android:clear": "node -e \"require('node:fs').rmSync('android', { recursive: true, force: true })\"",
     "ios": "expo run:ios",
     "ios:release": "expo run:ios --configuration Release",
     "web": "expo start --web",
-    "web:tauri": "PASEO_WEB_PLATFORM=tauri expo start --web",
     "lint": "expo lint",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:e2e": "playwright test",
     "test:e2e:ui": "playwright test --ui",
     "build": "npm run build:web",
-    "build:web": "expo export --platform web",
-    "build:web:tauri": "PASEO_WEB_PLATFORM=tauri expo export --platform web",
-    "deploy:web": "npm run build:web && wrangler pages deploy dist --project-name paseo-app"
+    "build:web": "npm run build:workspace-deps && expo export --platform web",
+    "deploy:web": "npm run build:web && wrangler pages deploy dist --project-name paseo-app --branch main"
   },
   "dependencies": {
-    "@boudra/expo-two-way-audio": "^0.1.3",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
     "@expo/vector-icons": "^15.0.2",
     "@floating-ui/react-native": "^0.10.7",
-    "@getpaseo/server": "0.1.27",
+    "@getpaseo/expo-two-way-audio": "0.1.53",
+    "@getpaseo/highlight": "0.1.53",
+    "@getpaseo/server": "0.1.53",
     "@gorhom/bottom-sheet": "^5.2.6",
     "@gorhom/portal": "^1.0.14",
-    "@lezer/common": "^1.5.0",
-    "@lezer/css": "^1.3.0",
-    "@lezer/highlight": "^1.2.3",
-    "@lezer/html": "^1.3.13",
-    "@lezer/javascript": "^1.5.4",
-    "@lezer/json": "^1.0.3",
-    "@lezer/markdown": "^1.6.2",
-    "@lezer/python": "^1.1.18",
     "@react-native-async-storage/async-storage": "2.2.0",
     "@react-native-masked-view/masked-view": "^0.3.2",
     "@react-native/normalize-colors": "^0.81.5",
@@ -52,10 +44,13 @@
     "@react-navigation/native": "^7.1.8",
     "@tanstack/react-query": "^5.90.11",
     "@tanstack/react-virtual": "^3.13.21",
-    "@tauri-apps/api": "^2.9.1",
-    "@tauri-apps/plugin-log": "^2.8.0",
+    "@xterm/addon-clipboard": "^0.2.0",
     "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-image": "^0.9.0",
+    "@xterm/addon-ligatures": "^0.10.0",
+    "@xterm/addon-search": "^0.16.0",
     "@xterm/addon-unicode11": "^0.9.0",
+    "@xterm/addon-web-links": "^0.12.0",
     "@xterm/addon-webgl": "^0.19.0",
     "@xterm/xterm": "^6.0.0",
     "base64-js": "^1.5.1",
@@ -84,7 +79,6 @@
     "expo-system-ui": "~6.0.7",
     "expo-updates": "~29.0.12",
     "expo-web-browser": "~15.0.8",
-    "lezer-elixir": "^1.1.2",
     "lucide-react-native": "^0.546.0",
     "mnemonic-id": "^3.2.7",
     "react": "19.1.4",
@@ -114,12 +108,15 @@
   "devDependencies": {
     "@playwright/test": "^1.56.1",
     "@types/react": "~19.2.0",
+    "@types/ws": "^8.18.1",
     "eas-cli": "^16.24.1",
     "eslint": "^9.25.0",
     "eslint-config-expo": "~10.0.0",
+    "material-icon-theme": "^5.32.0",
     "playwright": "^1.56.1",
     "typescript": "~5.9.2",
     "vitest": "^3.2.4",
-    "wrangler": "^4.59.1"
+    "wrangler": "^4.59.1",
+    "ws": "^8.20.0"
   }
 }

packages/app/playwright.config.ts

@@ -1,12 +1,13 @@
-import { defineConfig, devices } from '@playwright/test';
+import { defineConfig, devices } from "@playwright/test";
 
 // E2E_METRO_PORT is set dynamically by global-setup.ts after finding a free port
 // This allows multiple test runs in parallel across different worktrees
-const baseURL = process.env.E2E_BASE_URL ?? `http://localhost:${process.env.E2E_METRO_PORT ?? '8081'}`;
+const baseURL =
+  process.env.E2E_BASE_URL ?? `http://localhost:${process.env.E2E_METRO_PORT ?? "8081"}`;
 
 export default defineConfig({
-  testDir: './e2e',
-  globalSetup: './e2e/global-setup.ts',
+  testDir: "./e2e",
+  globalSetup: "./e2e/global-setup.ts",
   timeout: 60_000,
   expect: {
     timeout: 10_000,
@@ -16,17 +17,17 @@ export default defineConfig({
   fullyParallel: false,
   workers: 1,
   retries: process.env.CI ? 1 : 0,
-  reporter: [['list']],
+  reporter: [["list"]],
   use: {
     baseURL,
-    trace: 'retain-on-failure',
-    screenshot: 'only-on-failure',
-    video: 'retain-on-failure',
+    trace: "retain-on-failure",
+    screenshot: "only-on-failure",
+    video: "retain-on-failure",
   },
   projects: [
     {
-      name: 'Desktop Chrome',
-      use: { ...devices['Desktop Chrome'] },
+      name: "Desktop Chrome",
+      use: { ...devices["Desktop Chrome"] },
     },
   ],
   // Note: Metro is started by global-setup.ts on a dynamic port to allow parallel test runs

packages/app/playwright.firefox.config.ts

@@ -1,8 +1,7 @@
 import { defineConfig, devices } from "@playwright/test";
 
 const baseURL =
-  process.env.E2E_BASE_URL ??
-  `http://localhost:${process.env.E2E_METRO_PORT ?? "8081"}`;
+  process.env.E2E_BASE_URL ?? `http://localhost:${process.env.E2E_METRO_PORT ?? "8081"}`;
 
 export default defineConfig({
   testDir: "./e2e",

packages/app/playwright.webkit.tmp.config.ts

@@ -1,8 +1,7 @@
 import { defineConfig, devices } from "@playwright/test";
 
 const baseURL =
-  process.env.E2E_BASE_URL ??
-  `http://localhost:${process.env.E2E_METRO_PORT ?? "8081"}`;
+  process.env.E2E_BASE_URL ?? `http://localhost:${process.env.E2E_METRO_PORT ?? "8081"}`;
 
 export default defineConfig({
   testDir: "./e2e",

packages/app/public/index.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html lang="%LANG_ISO_CODE%">
+  <head>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta
+      name="viewport"
+      content="width=device-width, initial-scale=1, shrink-to-fit=no, viewport-fit=cover"
+    />
+    <title>%WEB_TITLE%</title>
+    <!-- The `react-native-web` recommended style reset: https://necolas.github.io/react-native-web/docs/setup/#root-element -->
+    <style id="expo-reset">
+      /* These styles make the body full-height */
+      html,
+      body {
+        height: 100%;
+      }
+      /* These styles disable body scrolling if you are using <ScrollView> */
+      body {
+        overflow: hidden;
+      }
+      /* Prevent white flash before React mounts */
+      @media (prefers-color-scheme: dark) {
+        html, body {
+          background-color: #181B1A;
+        }
+      }
+      /* These styles make the root element full-height */
+      #root {
+        display: flex;
+        height: 100%;
+        flex: 1;
+      }
+    </style>
+    <style>
+      button,
+      a,
+      input,
+      textarea,
+      select,
+      [role='button'],
+      [role='link'],
+      [role='textbox'],
+      [role='combobox'],
+      [role='tab'],
+      [role='switch'],
+      [role='checkbox'],
+      [role='slider'],
+      [role='menuitem'],
+      [tabindex],
+      [contenteditable='true'] {
+        -webkit-app-region: no-drag !important;
+      }
+    </style>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  </body>
+</html>