docs(bash): clarify output capture guidance

.github/VOUCHED.td

@@ -10,9 +10,6 @@
 adamdotdevin
 -agusbasari29 AI PR slop
 ariane-emory
--atharvau AI review spamming literally every PR
--danieljoshuanazareth
--danieljoshuanazareth
 edemaine
 -florianleibert
 fwang
@@ -20,9 +17,7 @@ iamdavidhill
 jayair
 kitlangton
 kommander
--opencode2026
 r44vc0rp
 rekram1-node
 -spider-yamet clawdbot/llm psychosis, spam pinging the team
 thdxr
--OpenCodeEngineer bot that spams issues

.github/actions/setup-bun/action.yml

@@ -3,6 +3,14 @@ description: "Setup Bun with caching and install dependencies"
 runs:
   using: "composite"
   steps:
+    - name: Cache Bun dependencies
+      uses: actions/cache@v4
+      with:
+        path: ~/.bun/install/cache
+        key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lockb') }}
+        restore-keys: |
+          ${{ runner.os }}-bun-
+
     - name: Get baseline download URL
       id: bun-url
       shell: bash
@@ -23,31 +31,6 @@ runs:
         bun-version-file: ${{ !steps.bun-url.outputs.url && 'package.json' || '' }}
         bun-download-url: ${{ steps.bun-url.outputs.url }}
 
-    - name: Get cache directory
-      id: cache
-      shell: bash
-      run: echo "dir=$(bun pm cache)" >> "$GITHUB_OUTPUT"
-
-    - name: Cache Bun dependencies
-      uses: actions/cache@v4
-      with:
-        path: ${{ steps.cache.outputs.dir }}
-        key: ${{ runner.os }}-bun-${{ hashFiles('**/bun.lock') }}
-        restore-keys: |
-          ${{ runner.os }}-bun-
-
-    - name: Install setuptools for distutils compatibility
-      run: python3 -m pip install setuptools || pip install setuptools || true
-      shell: bash
-
     - name: Install dependencies
-      run: |
-        # Workaround for patched peer variants
-        # e.g. ./patches/ for standard-openapi
-        # https://github.com/oven-sh/bun/issues/28147
-        if [ "$RUNNER_OS" = "Windows" ]; then
-          bun install --linker hoisted
-        else
-          bun install
-        fi
+      run: bun install
       shell: bash

.github/workflows/close-issues.yml

@@ -1,24 +0,0 @@
-name: close-issues
-
-on:
-  schedule:
-    - cron: "0 2 * * *" # Daily at 2:00 AM
-  workflow_dispatch:
-
-jobs:
-  close:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      issues: write
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: oven-sh/setup-bun@v2
-        with:
-          bun-version: latest
-
-      - name: Close stale issues
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
-        run: bun script/github/close-issues.ts

.github/workflows/deploy.yml

@@ -11,7 +11,7 @@ concurrency: ${{ github.workflow }}-${{ github.ref }}
 
 jobs:
   deploy:
-    runs-on: ubuntu-latest
+    runs-on: blacksmith-4vcpu-ubuntu-2404
     steps:
       - uses: actions/checkout@v3
 

.github/workflows/nix-hashes.yml

@@ -56,7 +56,7 @@ jobs:
           nix build ".#packages.${SYSTEM}.node_modules_updater" --no-link 2>&1 | tee "$BUILD_LOG" || true
 
           # Extract hash from build log with portability
-          HASH="$(nix run --inputs-from . nixpkgs#gnugrep -- -oP 'got:\s*\Ksha256-[A-Za-z0-9+/=]+' "$BUILD_LOG" | tail -n1 || true)"
+          HASH="$(grep -oE 'sha256-[A-Za-z0-9+/=]+' "$BUILD_LOG" | tail -n1 || true)"
 
           if [ -z "$HASH" ]; then
             echo "::error::Failed to compute hash for ${SYSTEM}"

.github/workflows/porter-app-5534-apn-relay.yml

@@ -1,27 +0,0 @@
-"on":
-    push:
-        branches:
-            - opencode-remote-voice
-name: Deploy to apn-relay
-jobs:
-    porter-deploy:
-        runs-on: ubuntu-latest
-        steps:
-            - name: Checkout code
-              uses: actions/checkout@v4
-            - name: Set Github tag
-              id: vars
-              run: echo "sha_short=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
-            - name: Setup porter
-              uses: porter-dev/setup-porter@v0.1.0
-            - name: Deploy stack
-              timeout-minutes: 30
-              run: porter apply
-              env:
-                PORTER_APP_NAME: apn-relay
-                PORTER_CLUSTER: "5534"
-                PORTER_DEPLOYMENT_TARGET_ID: d60e67f5-b0a6-4275-8ed6-3cebaf092147
-                PORTER_HOST: https://dashboard.porter.run
-                PORTER_PROJECT: "18525"
-                PORTER_TAG: ${{ steps.vars.outputs.sha_short }}
-                PORTER_TOKEN: ${{ secrets.PORTER_APP_18525_975734319 }}

.github/workflows/publish.yml

@@ -98,129 +98,16 @@ jobs:
       - uses: actions/upload-artifact@v4
         with:
           name: opencode-cli
-          path: |
-            packages/opencode/dist/opencode-darwin*
-            packages/opencode/dist/opencode-linux*
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: opencode-cli-windows
-          path: packages/opencode/dist/opencode-windows*
-    outputs:
-      version: ${{ needs.version.outputs.version }}
-
-  sign-cli-windows:
-    needs:
-      - build-cli
-      - version
-    runs-on: blacksmith-4vcpu-windows-2025
-    if: github.repository == 'anomalyco/opencode'
-    env:
-      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-      AZURE_TRUSTED_SIGNING_ACCOUNT_NAME: ${{ secrets.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-      AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE: ${{ secrets.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
-      AZURE_TRUSTED_SIGNING_ENDPOINT: ${{ secrets.AZURE_TRUSTED_SIGNING_ENDPOINT }}
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions/download-artifact@v4
-        with:
-          name: opencode-cli-windows
           path: packages/opencode/dist
 
-      - name: Setup git committer
-        id: committer
-        uses: ./.github/actions/setup-git-committer
-        with:
-          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
-          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
-
-      - name: Azure login
-        uses: azure/login@v2
-        with:
-          client-id: ${{ env.AZURE_CLIENT_ID }}
-          tenant-id: ${{ env.AZURE_TENANT_ID }}
-          subscription-id: ${{ env.AZURE_SUBSCRIPTION_ID }}
-
-      - uses: azure/artifact-signing-action@v1
-        with:
-          endpoint: ${{ env.AZURE_TRUSTED_SIGNING_ENDPOINT }}
-          signing-account-name: ${{ env.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-          certificate-profile-name: ${{ env.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
-          files: |
-            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64\bin\opencode.exe
-            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64\bin\opencode.exe
-            ${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline\bin\opencode.exe
-          exclude-environment-credential: true
-          exclude-workload-identity-credential: true
-          exclude-managed-identity-credential: true
-          exclude-shared-token-cache-credential: true
-          exclude-visual-studio-credential: true
-          exclude-visual-studio-code-credential: true
-          exclude-azure-cli-credential: false
-          exclude-azure-powershell-credential: true
-          exclude-azure-developer-cli-credential: true
-          exclude-interactive-browser-credential: true
-
-      - name: Verify Windows CLI signatures
-        shell: pwsh
-        run: |
-          $files = @(
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64\bin\opencode.exe",
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64\bin\opencode.exe",
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline\bin\opencode.exe"
-          )
-
-          foreach ($file in $files) {
-            $sig = Get-AuthenticodeSignature $file
-            if ($sig.Status -ne "Valid") {
-              throw "Invalid signature for ${file}: $($sig.Status)"
-            }
-          }
-
-      - name: Repack Windows CLI archives
-        working-directory: packages/opencode/dist
-        shell: pwsh
-        run: |
-          Compress-Archive -Path "opencode-windows-arm64\bin\*" -DestinationPath "opencode-windows-arm64.zip" -Force
-          Compress-Archive -Path "opencode-windows-x64\bin\*" -DestinationPath "opencode-windows-x64.zip" -Force
-          Compress-Archive -Path "opencode-windows-x64-baseline\bin\*" -DestinationPath "opencode-windows-x64-baseline.zip" -Force
-
-      - name: Upload signed Windows CLI release assets
-        if: needs.version.outputs.release != ''
-        shell: pwsh
-        env:
-          GH_TOKEN: ${{ steps.committer.outputs.token }}
-        run: |
-          gh release upload "v${{ needs.version.outputs.version }}" `
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-arm64.zip" `
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64.zip" `
-            "${{ github.workspace }}\packages\opencode\dist\opencode-windows-x64-baseline.zip" `
-            --clobber `
-            --repo "${{ needs.version.outputs.repo }}"
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: opencode-cli-signed-windows
-          path: |
-            packages/opencode/dist/opencode-windows-arm64
-            packages/opencode/dist/opencode-windows-x64
-            packages/opencode/dist/opencode-windows-x64-baseline
+    outputs:
+      version: ${{ needs.version.outputs.version }}
 
   build-tauri:
     needs:
       - build-cli
       - version
     continue-on-error: false
-    env:
-      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-      AZURE_TRUSTED_SIGNING_ACCOUNT_NAME: ${{ secrets.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-      AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE: ${{ secrets.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
-      AZURE_TRUSTED_SIGNING_ENDPOINT: ${{ secrets.AZURE_TRUSTED_SIGNING_ENDPOINT }}
     strategy:
       fail-fast: false
       matrix:
@@ -229,9 +116,6 @@ jobs:
             target: x86_64-apple-darwin
           - host: macos-latest
             target: aarch64-apple-darwin
-          # github-hosted: blacksmith lacks ARM64 MSVC cross-compilation toolchain
-          - host: windows-2025
-            target: aarch64-pc-windows-msvc
           - host: blacksmith-4vcpu-windows-2025
             target: x86_64-pc-windows-msvc
           - host: blacksmith-4vcpu-ubuntu-2404
@@ -266,18 +150,6 @@ jobs:
 
       - uses: ./.github/actions/setup-bun
 
-      - name: Azure login
-        if: runner.os == 'Windows'
-        uses: azure/login@v2
-        with:
-          client-id: ${{ env.AZURE_CLIENT_ID }}
-          tenant-id: ${{ env.AZURE_TENANT_ID }}
-          subscription-id: ${{ env.AZURE_SUBSCRIPTION_ID }}
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "24"
-
       - name: Cache apt packages
         if: contains(matrix.settings.host, 'ubuntu')
         uses: actions/cache@v4
@@ -312,7 +184,6 @@ jobs:
         env:
           OPENCODE_VERSION: ${{ needs.version.outputs.version }}
           GITHUB_TOKEN: ${{ steps.committer.outputs.token }}
-          OPENCODE_CLI_ARTIFACT: ${{ (runner.os == 'Windows' && 'opencode-cli-windows') || 'opencode-cli' }}
           RUST_TARGET: ${{ matrix.settings.target }}
           GH_TOKEN: ${{ github.token }}
           GITHUB_RUN_ID: ${{ github.run_id }}
@@ -369,184 +240,11 @@ jobs:
           APPLE_API_KEY: ${{ secrets.APPLE_API_KEY }}
           APPLE_API_KEY_PATH: ${{ runner.temp }}/apple-api-key.p8
 
-      - name: Verify signed Windows desktop artifacts
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          $files = @(
-            "${{ github.workspace }}\packages\desktop\src-tauri\sidecars\opencode-cli-${{ matrix.settings.target }}.exe"
-          )
-          $files += Get-ChildItem "${{ github.workspace }}\packages\desktop\src-tauri\target\${{ matrix.settings.target }}\release\bundle\nsis\*.exe" | Select-Object -ExpandProperty FullName
-
-          foreach ($file in $files) {
-            $sig = Get-AuthenticodeSignature $file
-            if ($sig.Status -ne "Valid") {
-              throw "Invalid signature for ${file}: $($sig.Status)"
-            }
-          }
-
-  build-electron:
-    needs:
-      - build-cli
-      - version
-    continue-on-error: false
-    env:
-      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
-      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
-      AZURE_SUBSCRIPTION_ID: ${{ secrets.AZURE_SUBSCRIPTION_ID }}
-      AZURE_TRUSTED_SIGNING_ACCOUNT_NAME: ${{ secrets.AZURE_TRUSTED_SIGNING_ACCOUNT_NAME }}
-      AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE: ${{ secrets.AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE }}
-      AZURE_TRUSTED_SIGNING_ENDPOINT: ${{ secrets.AZURE_TRUSTED_SIGNING_ENDPOINT }}
-    strategy:
-      fail-fast: false
-      matrix:
-        settings:
-          - host: macos-latest
-            target: x86_64-apple-darwin
-            platform_flag: --mac --x64
-          - host: macos-latest
-            target: aarch64-apple-darwin
-            platform_flag: --mac --arm64
-          # github-hosted: blacksmith lacks ARM64 MSVC cross-compilation toolchain
-          - host: "windows-2025"
-            target: aarch64-pc-windows-msvc
-            platform_flag: --win --arm64
-          - host: "blacksmith-4vcpu-windows-2025"
-            target: x86_64-pc-windows-msvc
-            platform_flag: --win
-          - host: "blacksmith-4vcpu-ubuntu-2404"
-            target: x86_64-unknown-linux-gnu
-            platform_flag: --linux
-          - host: "blacksmith-4vcpu-ubuntu-2404"
-            target: aarch64-unknown-linux-gnu
-            platform_flag: --linux
-    runs-on: ${{ matrix.settings.host }}
-    # if: github.ref_name == 'beta'
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: apple-actions/import-codesign-certs@v2
-        if: runner.os == 'macOS'
-        with:
-          keychain: build
-          p12-file-base64: ${{ secrets.APPLE_CERTIFICATE }}
-          p12-password: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-
-      - name: Setup Apple API Key
-        if: runner.os == 'macOS'
-        run: echo "${{ secrets.APPLE_API_KEY_PATH }}" > $RUNNER_TEMP/apple-api-key.p8
-
-      - uses: ./.github/actions/setup-bun
-
-      - name: Azure login
-        if: runner.os == 'Windows'
-        uses: azure/login@v2
-        with:
-          client-id: ${{ env.AZURE_CLIENT_ID }}
-          tenant-id: ${{ env.AZURE_TENANT_ID }}
-          subscription-id: ${{ env.AZURE_SUBSCRIPTION_ID }}
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "24"
-
-      - name: Cache apt packages
-        if: contains(matrix.settings.host, 'ubuntu')
-        uses: actions/cache@v4
-        with:
-          path: ~/apt-cache
-          key: ${{ runner.os }}-${{ matrix.settings.target }}-apt-electron-${{ hashFiles('.github/workflows/publish.yml') }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.settings.target }}-apt-electron-
-
-      - name: Install dependencies (ubuntu only)
-        if: contains(matrix.settings.host, 'ubuntu')
-        run: |
-          mkdir -p ~/apt-cache && chmod -R a+rw ~/apt-cache
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends -o dir::cache::archives="$HOME/apt-cache" rpm
-          sudo chmod -R a+rw ~/apt-cache
-
-      - name: Setup git committer
-        id: committer
-        uses: ./.github/actions/setup-git-committer
-        with:
-          opencode-app-id: ${{ vars.OPENCODE_APP_ID }}
-          opencode-app-secret: ${{ secrets.OPENCODE_APP_SECRET }}
-
-      - name: Prepare
-        run: bun ./scripts/prepare.ts
-        working-directory: packages/desktop-electron
-        env:
-          OPENCODE_VERSION: ${{ needs.version.outputs.version }}
-          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-          OPENCODE_CLI_ARTIFACT: ${{ (runner.os == 'Windows' && 'opencode-cli-windows') || 'opencode-cli' }}
-          RUST_TARGET: ${{ matrix.settings.target }}
-          GH_TOKEN: ${{ github.token }}
-          GITHUB_RUN_ID: ${{ github.run_id }}
-
-      - name: Build
-        run: bun run build
-        working-directory: packages/desktop-electron
-        env:
-          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-
-      - name: Package and publish
-        if: needs.version.outputs.release
-        run: npx electron-builder ${{ matrix.settings.platform_flag }} --publish always --config electron-builder.config.ts
-        working-directory: packages/desktop-electron
-        timeout-minutes: 60
-        env:
-          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-          GH_TOKEN: ${{ steps.committer.outputs.token }}
-          CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
-          CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
-          APPLE_API_KEY: ${{ runner.temp }}/apple-api-key.p8
-          APPLE_API_KEY_ID: ${{ secrets.APPLE_API_KEY }}
-          APPLE_API_ISSUER: ${{ secrets.APPLE_API_ISSUER }}
-
-      - name: Package (no publish)
-        if: ${{ !needs.version.outputs.release }}
-        run: npx electron-builder ${{ matrix.settings.platform_flag }} --publish never --config electron-builder.config.ts
-        working-directory: packages/desktop-electron
-        timeout-minutes: 60
-        env:
-          OPENCODE_CHANNEL: ${{ (github.ref_name == 'beta' && 'beta') || 'prod' }}
-
-      - name: Verify signed Windows Electron artifacts
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          $files = @()
-          $files += Get-ChildItem "${{ github.workspace }}\packages\desktop-electron\dist\*.exe" | Select-Object -ExpandProperty FullName
-          $files += Get-ChildItem "${{ github.workspace }}\packages\desktop-electron\dist\*unpacked\*.exe" | Select-Object -ExpandProperty FullName
-          $files += Get-ChildItem "${{ github.workspace }}\packages\desktop-electron\dist\*unpacked\resources\opencode-cli.exe" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName
-
-          foreach ($file in $files | Select-Object -Unique) {
-            $sig = Get-AuthenticodeSignature $file
-            if ($sig.Status -ne "Valid") {
-              throw "Invalid signature for ${file}: $($sig.Status)"
-            }
-          }
-
-      - uses: actions/upload-artifact@v4
-        with:
-          name: opencode-electron-${{ matrix.settings.target }}
-          path: packages/desktop-electron/dist/*
-
-      - uses: actions/upload-artifact@v4
-        if: needs.version.outputs.release
-        with:
-          name: latest-yml-${{ matrix.settings.target }}
-          path: packages/desktop-electron/dist/latest*.yml
-
   publish:
     needs:
       - version
       - build-cli
-      - sign-cli-windows
       - build-tauri
-      - build-electron
     runs-on: blacksmith-4vcpu-ubuntu-2404
     steps:
       - uses: actions/checkout@v3
@@ -583,22 +281,6 @@ jobs:
           name: opencode-cli
           path: packages/opencode/dist
 
-      - uses: actions/download-artifact@v4
-        with:
-          name: opencode-cli-windows
-          path: packages/opencode/dist
-
-      - uses: actions/download-artifact@v4
-        with:
-          name: opencode-cli-signed-windows
-          path: packages/opencode/dist
-
-      - uses: actions/download-artifact@v4
-        if: needs.version.outputs.release
-        with:
-          pattern: latest-yml-*
-          path: /tmp/latest-yml
-
       - name: Cache apt packages (AUR)
         uses: actions/cache@v4
         with:
@@ -626,4 +308,3 @@ jobs:
           GITHUB_TOKEN: ${{ steps.committer.outputs.token }}
           GH_REPO: ${{ needs.version.outputs.repo }}
           NPM_CONFIG_PROVENANCE: false
-          LATEST_YML_DIR: /tmp/latest-yml

.github/workflows/sign-cli.yml

@@ -0,0 +1,54 @@
+name: sign-cli
+
+on:
+  push:
+    branches:
+      - brendan/desktop-signpath
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  actions: read
+
+jobs:
+  sign-cli:
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    if: github.repository == 'anomalyco/opencode'
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-tags: true
+
+      - uses: ./.github/actions/setup-bun
+
+      - name: Build
+        run: |
+          ./packages/opencode/script/build.ts
+
+      - name: Upload unsigned Windows CLI
+        id: upload_unsigned_windows_cli
+        uses: actions/upload-artifact@v4
+        with:
+          name: unsigned-opencode-windows-cli
+          path: packages/opencode/dist/opencode-windows-x64/bin/opencode.exe
+          if-no-files-found: error
+
+      - name: Submit SignPath signing request
+        id: submit_signpath_signing_request
+        uses: signpath/github-action-submit-signing-request@v1
+        with:
+          api-token: ${{ secrets.SIGNPATH_API_KEY }}
+          organization-id: ${{ secrets.SIGNPATH_ORGANIZATION_ID }}
+          project-slug: ${{ secrets.SIGNPATH_PROJECT_SLUG }}
+          signing-policy-slug: ${{ secrets.SIGNPATH_SIGNING_POLICY_SLUG }}
+          artifact-configuration-slug: ${{ secrets.SIGNPATH_ARTIFACT_CONFIGURATION_SLUG }}
+          github-artifact-id: ${{ steps.upload_unsigned_windows_cli.outputs.artifact-id }}
+          wait-for-completion: true
+          output-artifact-directory: signed-opencode-cli
+
+      - name: Upload signed Windows CLI
+        uses: actions/upload-artifact@v4
+        with:
+          name: signed-opencode-windows-cli
+          path: signed-opencode-cli/*.exe
+          if-no-files-found: error

.github/workflows/stale-issues.yml

@@ -0,0 +1,33 @@
+name: stale-issues
+
+on:
+  schedule:
+    - cron: "30 1 * * *" # Daily at 1:30 AM
+  workflow_dispatch:
+
+env:
+  DAYS_BEFORE_STALE: 90
+  DAYS_BEFORE_CLOSE: 7
+
+jobs:
+  stale:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+    steps:
+      - uses: actions/stale@v10
+        with:
+          days-before-stale: ${{ env.DAYS_BEFORE_STALE }}
+          days-before-close: ${{ env.DAYS_BEFORE_CLOSE }}
+          stale-issue-label: "stale"
+          close-issue-message: |
+            [automated] Closing due to ${{ env.DAYS_BEFORE_STALE }}+ days of inactivity.
+
+            Feel free to reopen if you still need this!
+          stale-issue-message: |
+            [automated] This issue has had no activity for ${{ env.DAYS_BEFORE_STALE }} days.
+
+            It will be closed in ${{ env.DAYS_BEFORE_CLOSE }} days if there's no new activity.
+          remove-stale-when-updated: true
+          exempt-issue-labels: "pinned,security,feature-request,on-hold"
+          start-date: "2025-12-27"

.github/workflows/storybook.yml

@@ -1,38 +0,0 @@
-name: storybook
-
-on:
-  push:
-    branches: [dev]
-    paths:
-      - ".github/workflows/storybook.yml"
-      - "package.json"
-      - "bun.lock"
-      - "packages/storybook/**"
-      - "packages/ui/**"
-  pull_request:
-    branches: [dev]
-    paths:
-      - ".github/workflows/storybook.yml"
-      - "package.json"
-      - "bun.lock"
-      - "packages/storybook/**"
-      - "packages/ui/**"
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  build:
-    name: storybook build
-    runs-on: blacksmith-4vcpu-ubuntu-2404
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Bun
-        uses: ./.github/actions/setup-bun
-
-      - name: Build Storybook
-        run: bun --cwd packages/storybook build

.github/workflows/test.yml

@@ -6,16 +6,6 @@ on:
       - dev
   pull_request:
   workflow_dispatch:
-
-concurrency:
-  # Keep every run on dev so cancelled checks do not pollute the default branch
-  # commit history. PRs and other branches still share a group and cancel stale runs.
-  group: ${{ case(github.ref == 'refs/heads/dev', format('{0}-{1}', github.workflow, github.run_id), format('{0}-{1}', github.workflow, github.event.pull_request.number || github.ref)) }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read
-
 jobs:
   unit:
     name: unit (${{ matrix.settings.name }})
@@ -50,17 +40,20 @@ jobs:
 
   e2e:
     name: e2e (${{ matrix.settings.name }})
+    needs: unit
     strategy:
       fail-fast: false
       matrix:
         settings:
           - name: linux
             host: blacksmith-4vcpu-ubuntu-2404
+            playwright: bunx playwright install --with-deps
           - name: windows
             host: blacksmith-4vcpu-windows-2025
+            playwright: bunx playwright install
     runs-on: ${{ matrix.settings.host }}
     env:
-      PLAYWRIGHT_BROWSERS_PATH: ${{ github.workspace }}/.playwright-browsers
+      PLAYWRIGHT_BROWSERS_PATH: 0
     defaults:
       run:
         shell: bash
@@ -73,28 +66,9 @@ jobs:
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
-      - name: Read Playwright version
-        id: playwright-version
-        run: |
-          version=$(node -e 'console.log(require("./packages/app/package.json").devDependencies["@playwright/test"])')
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-
-      - name: Cache Playwright browsers
-        id: playwright-cache
-        uses: actions/cache@v4
-        with:
-          path: ${{ github.workspace }}/.playwright-browsers
-          key: ${{ runner.os }}-${{ runner.arch }}-playwright-${{ steps.playwright-version.outputs.version }}-chromium
-
-      - name: Install Playwright system dependencies
-        if: runner.os == 'Linux'
-        working-directory: packages/app
-        run: bunx playwright install-deps chromium
-
       - name: Install Playwright browsers
-        if: steps.playwright-cache.outputs.cache-hit != 'true'
         working-directory: packages/app
-        run: bunx playwright install chromium
+        run: ${{ matrix.settings.playwright }}
 
       - name: Run app e2e tests
         run: bun --cwd packages/app test:e2e:local
@@ -112,3 +86,18 @@ jobs:
           path: |
             packages/app/e2e/test-results
             packages/app/e2e/playwright-report
+
+  required:
+    name: test (linux)
+    runs-on: blacksmith-4vcpu-ubuntu-2404
+    needs:
+      - unit
+      - e2e
+    if: always()
+    steps:
+      - name: Verify upstream test jobs passed
+        run: |
+          echo "unit=${{ needs.unit.result }}"
+          echo "e2e=${{ needs.e2e.result }}"
+          test "${{ needs.unit.result }}" = "success"
+          test "${{ needs.e2e.result }}" = "success"

.github/workflows/vouch-manage-by-issue.yml

@@ -33,6 +33,6 @@ jobs:
         with:
           issue-id: ${{ github.event.issue.number }}
           comment-id: ${{ github.event.comment.id }}
-          roles: admin,maintain,write
+          roles: admin,maintain
         env:
           GITHUB_TOKEN: ${{ steps.committer.outputs.token }}

.gitignore

@@ -17,7 +17,7 @@ ts-dist
 /result
 refs
 Session.vim
-/opencode.json
+opencode.json
 a.out
 target
 .scripts

.opencode/.gitignore

@@ -1,6 +1,3 @@
-node_modules
-plans
-package.json
+plans/
 bun.lock
-.gitignore
-package-lock.json
+package.json

.opencode/agent/docs.md

@@ -0,0 +1,34 @@
+---
+description: ALWAYS use this when writing docs
+color: "#38A3EE"
+---
+
+You are an expert technical documentation writer
+
+You are not verbose
+
+Use a relaxed and friendly tone
+
+The title of the page should be a word or a 2-3 word phrase
+
+The description should be one short line, should not start with "The", should
+avoid repeating the title of the page, should be 5-10 words long
+
+Chunks of text should not be more than 2 sentences long
+
+Each section is separated by a divider of 3 dashes
+
+The section titles are short with only the first letter of the word capitalized
+
+The section titles are in the imperative mood
+
+The section titles should not repeat the term used in the page title, for
+example, if the page title is "Models", avoid using a section title like "Add
+new models". This might be unavoidable in some cases, but try to avoid it.
+
+Check out the /packages/web/src/content/docs/docs/index.mdx as an example.
+
+For JS or TS code snippets remove trailing semicolons and any trailing commas
+that might not be needed.
+
+If you are making a commit prefix the commit message with `docs:`

.opencode/agent/translator.md

@@ -1,7 +1,7 @@
 ---
 description: Translate content for a specified locale while preserving technical terms
 mode: subagent
-model: opencode/gpt-5.4
+model: opencode/gemini-3-pro
 ---
 
 You are a professional translator and localization specialist.

.opencode/command/changelog.md

@@ -1,23 +0,0 @@
----
-model: opencode/kimi-k2.5
----
-
-create UPCOMING_CHANGELOG.md
-
-it should have sections
-
-```
-## TUI
-
-## Desktop
-
-## Core
-
-## Misc
-```
-
-fetch the latest github release for this repository to determine the last release version.
-
-find each PR that was merged since the last release
-
-for each PR spawn a subagent to summarize what the PR was about. focus on user facing changes. if it was entirely internal or code related you can ignore it. also skip docs updates. each subagent should append its summary to UPCOMING_CHANGELOG.md into the appropriate section.

.opencode/opencode.jsonc

@@ -5,11 +5,6 @@
       "options": {},
     },
   },
-  "permission": {
-    "edit": {
-      "packages/opencode/migration/*": "deny",
-    },
-  },
   "mcp": {},
   "tools": {
     "github-triage": false,

.opencode/plugins/smoke-theme.json

@@ -1,223 +0,0 @@
-{
-  "$schema": "https://opencode.ai/theme.json",
-  "defs": {
-    "nord0": "#2E3440",
-    "nord1": "#3B4252",
-    "nord2": "#434C5E",
-    "nord3": "#4C566A",
-    "nord4": "#D8DEE9",
-    "nord5": "#E5E9F0",
-    "nord6": "#ECEFF4",
-    "nord7": "#8FBCBB",
-    "nord8": "#88C0D0",
-    "nord9": "#81A1C1",
-    "nord10": "#5E81AC",
-    "nord11": "#BF616A",
-    "nord12": "#D08770",
-    "nord13": "#EBCB8B",
-    "nord14": "#A3BE8C",
-    "nord15": "#B48EAD"
-  },
-  "theme": {
-    "primary": {
-      "dark": "nord10",
-      "light": "nord9"
-    },
-    "secondary": {
-      "dark": "nord9",
-      "light": "nord9"
-    },
-    "accent": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "error": {
-      "dark": "nord11",
-      "light": "nord11"
-    },
-    "warning": {
-      "dark": "nord12",
-      "light": "nord12"
-    },
-    "success": {
-      "dark": "nord14",
-      "light": "nord14"
-    },
-    "info": {
-      "dark": "nord8",
-      "light": "nord10"
-    },
-    "text": {
-      "dark": "nord6",
-      "light": "nord0"
-    },
-    "textMuted": {
-      "dark": "#8B95A7",
-      "light": "nord1"
-    },
-    "background": {
-      "dark": "nord0",
-      "light": "nord6"
-    },
-    "backgroundPanel": {
-      "dark": "nord1",
-      "light": "nord5"
-    },
-    "backgroundElement": {
-      "dark": "nord2",
-      "light": "nord4"
-    },
-    "border": {
-      "dark": "nord2",
-      "light": "nord3"
-    },
-    "borderActive": {
-      "dark": "nord3",
-      "light": "nord2"
-    },
-    "borderSubtle": {
-      "dark": "nord2",
-      "light": "nord3"
-    },
-    "diffAdded": {
-      "dark": "nord14",
-      "light": "nord14"
-    },
-    "diffRemoved": {
-      "dark": "nord11",
-      "light": "nord11"
-    },
-    "diffContext": {
-      "dark": "#8B95A7",
-      "light": "nord3"
-    },
-    "diffHunkHeader": {
-      "dark": "#8B95A7",
-      "light": "nord3"
-    },
-    "diffHighlightAdded": {
-      "dark": "nord14",
-      "light": "nord14"
-    },
-    "diffHighlightRemoved": {
-      "dark": "nord11",
-      "light": "nord11"
-    },
-    "diffAddedBg": {
-      "dark": "#36413C",
-      "light": "#E6EBE7"
-    },
-    "diffRemovedBg": {
-      "dark": "#43393D",
-      "light": "#ECE6E8"
-    },
-    "diffContextBg": {
-      "dark": "nord1",
-      "light": "nord5"
-    },
-    "diffLineNumber": {
-      "dark": "nord2",
-      "light": "nord4"
-    },
-    "diffAddedLineNumberBg": {
-      "dark": "#303A35",
-      "light": "#DDE4DF"
-    },
-    "diffRemovedLineNumberBg": {
-      "dark": "#3C3336",
-      "light": "#E4DDE0"
-    },
-    "markdownText": {
-      "dark": "nord4",
-      "light": "nord0"
-    },
-    "markdownHeading": {
-      "dark": "nord8",
-      "light": "nord10"
-    },
-    "markdownLink": {
-      "dark": "nord9",
-      "light": "nord9"
-    },
-    "markdownLinkText": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "markdownCode": {
-      "dark": "nord14",
-      "light": "nord14"
-    },
-    "markdownBlockQuote": {
-      "dark": "#8B95A7",
-      "light": "nord3"
-    },
-    "markdownEmph": {
-      "dark": "nord12",
-      "light": "nord12"
-    },
-    "markdownStrong": {
-      "dark": "nord13",
-      "light": "nord13"
-    },
-    "markdownHorizontalRule": {
-      "dark": "#8B95A7",
-      "light": "nord3"
-    },
-    "markdownListItem": {
-      "dark": "nord8",
-      "light": "nord10"
-    },
-    "markdownListEnumeration": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "markdownImage": {
-      "dark": "nord9",
-      "light": "nord9"
-    },
-    "markdownImageText": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "markdownCodeBlock": {
-      "dark": "nord4",
-      "light": "nord0"
-    },
-    "syntaxComment": {
-      "dark": "#8B95A7",
-      "light": "nord3"
-    },
-    "syntaxKeyword": {
-      "dark": "nord9",
-      "light": "nord9"
-    },
-    "syntaxFunction": {
-      "dark": "nord8",
-      "light": "nord8"
-    },
-    "syntaxVariable": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "syntaxString": {
-      "dark": "nord14",
-      "light": "nord14"
-    },
-    "syntaxNumber": {
-      "dark": "nord15",
-      "light": "nord15"
-    },
-    "syntaxType": {
-      "dark": "nord7",
-      "light": "nord7"
-    },
-    "syntaxOperator": {
-      "dark": "nord9",
-      "light": "nord9"
-    },
-    "syntaxPunctuation": {
-      "dark": "nord4",
-      "light": "nord0"
-    }
-  }
-}

.opencode/plugins/tui-smoke.tsx

@@ -1,861 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { useKeyboard, useTerminalDimensions } from "@opentui/solid"
-import { RGBA, VignetteEffect } from "@opentui/core"
-import type {
-  TuiKeybindSet,
-  TuiPlugin,
-  TuiPluginApi,
-  TuiPluginMeta,
-  TuiPluginModule,
-  TuiSlotPlugin,
-} from "@opencode-ai/plugin/tui"
-
-const tabs = ["overview", "counter", "help"]
-const bind = {
-  modal: "ctrl+shift+m",
-  screen: "ctrl+shift+o",
-  home: "escape,ctrl+h",
-  left: "left,h",
-  right: "right,l",
-  up: "up,k",
-  down: "down,j",
-  alert: "a",
-  confirm: "c",
-  prompt: "p",
-  select: "s",
-  modal_accept: "enter,return",
-  modal_close: "escape",
-  dialog_close: "escape",
-  local: "x",
-  local_push: "enter,return",
-  local_close: "q,backspace",
-  host: "z",
-}
-
-const pick = (value: unknown, fallback: string) => {
-  if (typeof value !== "string") return fallback
-  if (!value.trim()) return fallback
-  return value
-}
-
-const num = (value: unknown, fallback: number) => {
-  if (typeof value !== "number") return fallback
-  return value
-}
-
-const rec = (value: unknown) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return
-  return Object.fromEntries(Object.entries(value))
-}
-
-type Cfg = {
-  label: string
-  route: string
-  vignette: number
-  keybinds: Record<string, unknown> | undefined
-}
-
-type Route = {
-  modal: string
-  screen: string
-}
-
-type State = {
-  tab: number
-  count: number
-  source: string
-  note: string
-  selected: string
-  local: number
-}
-
-const cfg = (options: Record<string, unknown> | undefined) => {
-  return {
-    label: pick(options?.label, "smoke"),
-    route: pick(options?.route, "workspace-smoke"),
-    vignette: Math.max(0, num(options?.vignette, 0.35)),
-    keybinds: rec(options?.keybinds),
-  }
-}
-
-const names = (input: Cfg) => {
-  return {
-    modal: `${input.route}.modal`,
-    screen: `${input.route}.screen`,
-  }
-}
-
-type Keys = TuiKeybindSet
-const ui = {
-  panel: "#1d1d1d",
-  border: "#4a4a4a",
-  text: "#f0f0f0",
-  muted: "#a5a5a5",
-  accent: "#5f87ff",
-}
-
-type Color = RGBA | string
-
-const ink = (map: Record<string, unknown>, name: string, fallback: string): Color => {
-  const value = map[name]
-  if (typeof value === "string") return value
-  if (value instanceof RGBA) return value
-  return fallback
-}
-
-const look = (map: Record<string, unknown>) => {
-  return {
-    panel: ink(map, "backgroundPanel", ui.panel),
-    border: ink(map, "border", ui.border),
-    text: ink(map, "text", ui.text),
-    muted: ink(map, "textMuted", ui.muted),
-    accent: ink(map, "primary", ui.accent),
-    selected: ink(map, "selectedListItemText", ui.text),
-  }
-}
-
-const tone = (api: TuiPluginApi) => {
-  return look(api.theme.current)
-}
-
-type Skin = {
-  panel: Color
-  border: Color
-  text: Color
-  muted: Color
-  accent: Color
-  selected: Color
-}
-
-const Btn = (props: { txt: string; run: () => void; skin: Skin; on?: boolean }) => {
-  return (
-    <box
-      onMouseUp={() => {
-        props.run()
-      }}
-      backgroundColor={props.on ? props.skin.accent : props.skin.border}
-      paddingLeft={1}
-      paddingRight={1}
-    >
-      <text fg={props.on ? props.skin.selected : props.skin.text}>{props.txt}</text>
-    </box>
-  )
-}
-
-const parse = (params: Record<string, unknown> | undefined) => {
-  const tab = typeof params?.tab === "number" ? params.tab : 0
-  const count = typeof params?.count === "number" ? params.count : 0
-  const source = typeof params?.source === "string" ? params.source : "unknown"
-  const note = typeof params?.note === "string" ? params.note : ""
-  const selected = typeof params?.selected === "string" ? params.selected : ""
-  const local = typeof params?.local === "number" ? params.local : 0
-  return {
-    tab: Math.max(0, Math.min(tab, tabs.length - 1)),
-    count,
-    source,
-    note,
-    selected,
-    local: Math.max(0, local),
-  }
-}
-
-const current = (api: TuiPluginApi, route: Route) => {
-  const value = api.route.current
-  const ok = Object.values(route).includes(value.name)
-  if (!ok) return parse(undefined)
-  if (!("params" in value)) return parse(undefined)
-  return parse(value.params)
-}
-
-const opts = [
-  {
-    title: "Overview",
-    value: 0,
-    description: "Switch to overview tab",
-  },
-  {
-    title: "Counter",
-    value: 1,
-    description: "Switch to counter tab",
-  },
-  {
-    title: "Help",
-    value: 2,
-    description: "Switch to help tab",
-  },
-]
-
-const host = (api: TuiPluginApi, input: Cfg, skin: Skin) => {
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() => (
-    <box paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1} flexDirection="column">
-      <text fg={skin.text}>
-        <b>{input.label} host overlay</b>
-      </text>
-      <text fg={skin.muted}>Using api.ui.dialog stack with built-in backdrop</text>
-      <text fg={skin.muted}>esc closes · depth {api.ui.dialog.depth}</text>
-      <box flexDirection="row" gap={1}>
-        <Btn txt="close" run={() => api.ui.dialog.clear()} skin={skin} on />
-      </box>
-    </box>
-  ))
-}
-
-const warn = (api: TuiPluginApi, route: Route, value: State) => {
-  const DialogAlert = api.ui.DialogAlert
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() => (
-    <DialogAlert
-      title="Smoke alert"
-      message="Testing built-in alert dialog"
-      onConfirm={() => api.route.navigate(route.screen, { ...value, source: "alert" })}
-    />
-  ))
-}
-
-const check = (api: TuiPluginApi, route: Route, value: State) => {
-  const DialogConfirm = api.ui.DialogConfirm
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() => (
-    <DialogConfirm
-      title="Smoke confirm"
-      message="Apply +1 to counter?"
-      onConfirm={() => api.route.navigate(route.screen, { ...value, count: value.count + 1, source: "confirm" })}
-      onCancel={() => api.route.navigate(route.screen, { ...value, source: "confirm-cancel" })}
-    />
-  ))
-}
-
-const entry = (api: TuiPluginApi, route: Route, value: State) => {
-  const DialogPrompt = api.ui.DialogPrompt
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() => (
-    <DialogPrompt
-      title="Smoke prompt"
-      value={value.note}
-      onConfirm={(note) => {
-        api.ui.dialog.clear()
-        api.route.navigate(route.screen, { ...value, note, source: "prompt" })
-      }}
-      onCancel={() => {
-        api.ui.dialog.clear()
-        api.route.navigate(route.screen, value)
-      }}
-    />
-  ))
-}
-
-const picker = (api: TuiPluginApi, route: Route, value: State) => {
-  const DialogSelect = api.ui.DialogSelect
-  api.ui.dialog.setSize("medium")
-  api.ui.dialog.replace(() => (
-    <DialogSelect
-      title="Smoke select"
-      options={opts}
-      current={value.tab}
-      onSelect={(item) => {
-        api.ui.dialog.clear()
-        api.route.navigate(route.screen, {
-          ...value,
-          tab: typeof item.value === "number" ? item.value : value.tab,
-          selected: item.title,
-          source: "select",
-        })
-      }}
-    />
-  ))
-}
-
-const Screen = (props: {
-  api: TuiPluginApi
-  input: Cfg
-  route: Route
-  keys: Keys
-  meta: TuiPluginMeta
-  params?: Record<string, unknown>
-}) => {
-  const dim = useTerminalDimensions()
-  const value = parse(props.params)
-  const skin = tone(props.api)
-  const set = (local: number, base?: State) => {
-    const next = base ?? current(props.api, props.route)
-    props.api.route.navigate(props.route.screen, { ...next, local: Math.max(0, local), source: "local" })
-  }
-  const push = (base?: State) => {
-    const next = base ?? current(props.api, props.route)
-    set(next.local + 1, next)
-  }
-  const open = () => {
-    const next = current(props.api, props.route)
-    if (next.local > 0) return
-    set(1, next)
-  }
-  const pop = (base?: State) => {
-    const next = base ?? current(props.api, props.route)
-    const local = Math.max(0, next.local - 1)
-    set(local, next)
-  }
-  const show = () => {
-    setTimeout(() => {
-      open()
-    }, 0)
-  }
-  useKeyboard((evt) => {
-    if (props.api.route.current.name !== props.route.screen) return
-    const next = current(props.api, props.route)
-    if (props.api.ui.dialog.open) {
-      if (props.keys.match("dialog_close", evt)) {
-        evt.preventDefault()
-        evt.stopPropagation()
-        props.api.ui.dialog.clear()
-        return
-      }
-      return
-    }
-
-    if (next.local > 0) {
-      if (evt.name === "escape" || props.keys.match("local_close", evt)) {
-        evt.preventDefault()
-        evt.stopPropagation()
-        pop(next)
-        return
-      }
-
-      if (props.keys.match("local_push", evt)) {
-        evt.preventDefault()
-        evt.stopPropagation()
-        push(next)
-        return
-      }
-      return
-    }
-
-    if (props.keys.match("home", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate("home")
-      return
-    }
-
-    if (props.keys.match("left", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.screen, { ...next, tab: (next.tab - 1 + tabs.length) % tabs.length })
-      return
-    }
-
-    if (props.keys.match("right", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.screen, { ...next, tab: (next.tab + 1) % tabs.length })
-      return
-    }
-
-    if (props.keys.match("up", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.screen, { ...next, count: next.count + 1 })
-      return
-    }
-
-    if (props.keys.match("down", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.screen, { ...next, count: next.count - 1 })
-      return
-    }
-
-    if (props.keys.match("modal", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.modal, next)
-      return
-    }
-
-    if (props.keys.match("local", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      open()
-      return
-    }
-
-    if (props.keys.match("host", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      host(props.api, props.input, skin)
-      return
-    }
-
-    if (props.keys.match("alert", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      warn(props.api, props.route, next)
-      return
-    }
-
-    if (props.keys.match("confirm", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      check(props.api, props.route, next)
-      return
-    }
-
-    if (props.keys.match("prompt", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      entry(props.api, props.route, next)
-      return
-    }
-
-    if (props.keys.match("select", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      picker(props.api, props.route, next)
-    }
-  })
-
-  return (
-    <box width={dim().width} height={dim().height} backgroundColor={skin.panel} position="relative">
-      <box
-        flexDirection="column"
-        width="100%"
-        height="100%"
-        paddingTop={1}
-        paddingBottom={1}
-        paddingLeft={2}
-        paddingRight={2}
-      >
-        <box flexDirection="row" justifyContent="space-between" paddingBottom={1}>
-          <text fg={skin.text}>
-            <b>{props.input.label} screen</b>
-            <span style={{ fg: skin.muted }}> plugin route</span>
-          </text>
-          <text fg={skin.muted}>{props.keys.print("home")} home</text>
-        </box>
-
-        <box flexDirection="row" gap={1} paddingBottom={1}>
-          {tabs.map((item, i) => {
-            const on = value.tab === i
-            return (
-              <Btn
-                txt={item}
-                run={() => props.api.route.navigate(props.route.screen, { ...value, tab: i })}
-                skin={skin}
-                on={on}
-              />
-            )
-          })}
-        </box>
-
-        <box
-          border
-          borderColor={skin.border}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          paddingRight={2}
-          flexGrow={1}
-        >
-          {value.tab === 0 ? (
-            <box flexDirection="column" gap={1}>
-              <text fg={skin.text}>Route: {props.route.screen}</text>
-              <text fg={skin.muted}>plugin state: {props.meta.state}</text>
-              <text fg={skin.muted}>
-                first: {props.meta.state === "first" ? "yes" : "no"} · updated:{" "}
-                {props.meta.state === "updated" ? "yes" : "no"} · loads: {props.meta.load_count}
-              </text>
-              <text fg={skin.muted}>plugin source: {props.meta.source}</text>
-              <text fg={skin.muted}>source: {value.source}</text>
-              <text fg={skin.muted}>note: {value.note || "(none)"}</text>
-              <text fg={skin.muted}>selected: {value.selected || "(none)"}</text>
-              <text fg={skin.muted}>local stack depth: {value.local}</text>
-              <text fg={skin.muted}>host stack open: {props.api.ui.dialog.open ? "yes" : "no"}</text>
-            </box>
-          ) : null}
-
-          {value.tab === 1 ? (
-            <box flexDirection="column" gap={1}>
-              <text fg={skin.text}>Counter: {value.count}</text>
-              <text fg={skin.muted}>
-                {props.keys.print("up")} / {props.keys.print("down")} change value
-              </text>
-            </box>
-          ) : null}
-
-          {value.tab === 2 ? (
-            <box flexDirection="column" gap={1}>
-              <text fg={skin.muted}>
-                {props.keys.print("modal")} modal | {props.keys.print("alert")} alert | {props.keys.print("confirm")}{" "}
-                confirm | {props.keys.print("prompt")} prompt | {props.keys.print("select")} select
-              </text>
-              <text fg={skin.muted}>
-                {props.keys.print("local")} local stack | {props.keys.print("host")} host stack
-              </text>
-              <text fg={skin.muted}>
-                local open: {props.keys.print("local_push")} push nested · esc or {props.keys.print("local_close")}{" "}
-                close
-              </text>
-              <text fg={skin.muted}>{props.keys.print("home")} returns home</text>
-            </box>
-          ) : null}
-        </box>
-
-        <box flexDirection="row" gap={1} paddingTop={1}>
-          <Btn txt="go home" run={() => props.api.route.navigate("home")} skin={skin} />
-          <Btn txt="modal" run={() => props.api.route.navigate(props.route.modal, value)} skin={skin} on />
-          <Btn txt="local overlay" run={show} skin={skin} />
-          <Btn txt="host overlay" run={() => host(props.api, props.input, skin)} skin={skin} />
-          <Btn txt="alert" run={() => warn(props.api, props.route, value)} skin={skin} />
-          <Btn txt="confirm" run={() => check(props.api, props.route, value)} skin={skin} />
-          <Btn txt="prompt" run={() => entry(props.api, props.route, value)} skin={skin} />
-          <Btn txt="select" run={() => picker(props.api, props.route, value)} skin={skin} />
-        </box>
-      </box>
-
-      <box
-        visible={value.local > 0}
-        width={dim().width}
-        height={dim().height}
-        alignItems="center"
-        position="absolute"
-        zIndex={3000}
-        paddingTop={dim().height / 4}
-        left={0}
-        top={0}
-        backgroundColor={RGBA.fromInts(0, 0, 0, 160)}
-        onMouseUp={() => {
-          pop()
-        }}
-      >
-        <box
-          onMouseUp={(evt) => {
-            evt.stopPropagation()
-          }}
-          width={60}
-          maxWidth={dim().width - 2}
-          backgroundColor={skin.panel}
-          border
-          borderColor={skin.border}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          paddingRight={2}
-          gap={1}
-          flexDirection="column"
-        >
-          <text fg={skin.text}>
-            <b>{props.input.label} local overlay</b>
-          </text>
-          <text fg={skin.muted}>Plugin-owned stack depth: {value.local}</text>
-          <text fg={skin.muted}>
-            {props.keys.print("local_push")} push nested · {props.keys.print("local_close")} pop/close
-          </text>
-          <box flexDirection="row" gap={1}>
-            <Btn txt="push" run={push} skin={skin} on />
-            <Btn txt="pop" run={pop} skin={skin} />
-          </box>
-        </box>
-      </box>
-    </box>
-  )
-}
-
-const Modal = (props: {
-  api: TuiPluginApi
-  input: Cfg
-  route: Route
-  keys: Keys
-  params?: Record<string, unknown>
-}) => {
-  const Dialog = props.api.ui.Dialog
-  const value = parse(props.params)
-  const skin = tone(props.api)
-
-  useKeyboard((evt) => {
-    if (props.api.route.current.name !== props.route.modal) return
-
-    if (props.keys.match("modal_accept", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate(props.route.screen, { ...value, source: "modal" })
-      return
-    }
-
-    if (props.keys.match("modal_close", evt)) {
-      evt.preventDefault()
-      evt.stopPropagation()
-      props.api.route.navigate("home")
-    }
-  })
-
-  return (
-    <box width="100%" height="100%" backgroundColor={skin.panel}>
-      <Dialog onClose={() => props.api.route.navigate("home")}>
-        <box paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1} flexDirection="column">
-          <text fg={skin.text}>
-            <b>{props.input.label} modal</b>
-          </text>
-          <text fg={skin.muted}>{props.keys.print("modal")} modal command</text>
-          <text fg={skin.muted}>{props.keys.print("screen")} screen command</text>
-          <text fg={skin.muted}>
-            {props.keys.print("modal_accept")} opens screen · {props.keys.print("modal_close")} closes
-          </text>
-          <box flexDirection="row" gap={1}>
-            <Btn
-              txt="open screen"
-              run={() => props.api.route.navigate(props.route.screen, { ...value, source: "modal" })}
-              skin={skin}
-              on
-            />
-            <Btn txt="cancel" run={() => props.api.route.navigate("home")} skin={skin} />
-          </box>
-        </box>
-      </Dialog>
-    </box>
-  )
-}
-
-const home = (input: Cfg): TuiSlotPlugin => ({
-  slots: {
-    home_logo(ctx) {
-      const map = ctx.theme.current
-      const skin = look(map)
-      const art = [
-        "                                  $$\\",
-        "                                  $$ |",
-        " $$$$$$$\\ $$$$$$\\$$$$\\   $$$$$$\\  $$ |  $$\\  $$$$$$\\",
-        "$$  _____|$$  _$$  _$$\\ $$  __$$\\ $$ | $$  |$$  __$$\\",
-        "\\$$$$$$\\  $$ / $$ / $$ |$$ /  $$ |$$$$$$  / $$$$$$$$ |",
-        " \\____$$\\ $$ | $$ | $$ |$$ |  $$ |$$  _$$<  $$   ____|",
-        "$$$$$$$  |$$ | $$ | $$ |\\$$$$$$  |$$ | \\$$\\ \\$$$$$$$\\",
-        "\\_______/ \\__| \\__| \\__| \\______/ \\__|  \\__| \\_______|",
-      ]
-      const fill = [
-        skin.accent,
-        skin.muted,
-        ink(map, "info", ui.accent),
-        skin.text,
-        ink(map, "success", ui.accent),
-        ink(map, "warning", ui.accent),
-        ink(map, "secondary", ui.accent),
-        ink(map, "error", ui.accent),
-      ]
-
-      return (
-        <box flexDirection="column">
-          {art.map((line, i) => (
-            <text fg={fill[i]}>{line}</text>
-          ))}
-        </box>
-      )
-    },
-    home_bottom(ctx) {
-      const skin = look(ctx.theme.current)
-      const text = "extra content in the unified home bottom slot"
-
-      return (
-        <box width="100%" maxWidth={75} alignItems="center" paddingTop={1} flexShrink={0} gap={1}>
-          <box
-            border
-            borderColor={skin.border}
-            backgroundColor={skin.panel}
-            paddingTop={1}
-            paddingBottom={1}
-            paddingLeft={2}
-            paddingRight={2}
-            width="100%"
-          >
-            <text fg={skin.muted}>
-              <span style={{ fg: skin.accent }}>{input.label}</span> {text}
-            </text>
-          </box>
-        </box>
-      )
-    },
-  },
-})
-
-const block = (input: Cfg, order: number, title: string, text: string): TuiSlotPlugin => ({
-  order,
-  slots: {
-    sidebar_content(ctx, value) {
-      const skin = look(ctx.theme.current)
-
-      return (
-        <box
-          border
-          borderColor={skin.border}
-          backgroundColor={skin.panel}
-          paddingTop={1}
-          paddingBottom={1}
-          paddingLeft={2}
-          paddingRight={2}
-          flexDirection="column"
-          gap={1}
-        >
-          <text fg={skin.accent}>
-            <b>{title}</b>
-          </text>
-          <text fg={skin.text}>{text}</text>
-          <text fg={skin.muted}>
-            {input.label} order {order} · session {value.session_id.slice(0, 8)}
-          </text>
-        </box>
-      )
-    },
-  },
-})
-
-const slot = (input: Cfg): TuiSlotPlugin[] => [
-  home(input),
-  block(input, 50, "Smoke above", "renders above internal sidebar blocks"),
-  block(input, 250, "Smoke between", "renders between internal sidebar blocks"),
-  block(input, 650, "Smoke below", "renders below internal sidebar blocks"),
-]
-
-const reg = (api: TuiPluginApi, input: Cfg, keys: Keys) => {
-  const route = names(input)
-  api.command.register(() => [
-    {
-      title: `${input.label} modal`,
-      value: "plugin.smoke.modal",
-      keybind: keys.get("modal"),
-      category: "Plugin",
-      slash: {
-        name: "smoke",
-      },
-      onSelect: () => {
-        api.route.navigate(route.modal, { source: "command" })
-      },
-    },
-    {
-      title: `${input.label} screen`,
-      value: "plugin.smoke.screen",
-      keybind: keys.get("screen"),
-      category: "Plugin",
-      slash: {
-        name: "smoke-screen",
-      },
-      onSelect: () => {
-        api.route.navigate(route.screen, { source: "command", tab: 0, count: 0 })
-      },
-    },
-    {
-      title: `${input.label} alert dialog`,
-      value: "plugin.smoke.alert",
-      category: "Plugin",
-      slash: {
-        name: "smoke-alert",
-      },
-      onSelect: () => {
-        warn(api, route, current(api, route))
-      },
-    },
-    {
-      title: `${input.label} confirm dialog`,
-      value: "plugin.smoke.confirm",
-      category: "Plugin",
-      slash: {
-        name: "smoke-confirm",
-      },
-      onSelect: () => {
-        check(api, route, current(api, route))
-      },
-    },
-    {
-      title: `${input.label} prompt dialog`,
-      value: "plugin.smoke.prompt",
-      category: "Plugin",
-      slash: {
-        name: "smoke-prompt",
-      },
-      onSelect: () => {
-        entry(api, route, current(api, route))
-      },
-    },
-    {
-      title: `${input.label} select dialog`,
-      value: "plugin.smoke.select",
-      category: "Plugin",
-      slash: {
-        name: "smoke-select",
-      },
-      onSelect: () => {
-        picker(api, route, current(api, route))
-      },
-    },
-    {
-      title: `${input.label} host overlay`,
-      value: "plugin.smoke.host",
-      category: "Plugin",
-      slash: {
-        name: "smoke-host",
-      },
-      onSelect: () => {
-        host(api, input, tone(api))
-      },
-    },
-    {
-      title: `${input.label} go home`,
-      value: "plugin.smoke.home",
-      category: "Plugin",
-      enabled: api.route.current.name !== "home",
-      onSelect: () => {
-        api.route.navigate("home")
-      },
-    },
-    {
-      title: `${input.label} toast`,
-      value: "plugin.smoke.toast",
-      category: "Plugin",
-      onSelect: () => {
-        api.ui.toast({
-          variant: "info",
-          title: "Smoke",
-          message: "Plugin toast works",
-          duration: 2000,
-        })
-      },
-    },
-  ])
-}
-
-const tui: TuiPlugin = async (api, options, meta) => {
-  if (options?.enabled === false) return
-
-  await api.theme.install("./smoke-theme.json")
-  api.theme.set("smoke-theme")
-
-  const value = cfg(options ?? undefined)
-  const route = names(value)
-  const keys = api.keybind.create(bind, value.keybinds)
-  const fx = new VignetteEffect(value.vignette)
-  const post = fx.apply.bind(fx)
-  api.renderer.addPostProcessFn(post)
-  api.lifecycle.onDispose(() => {
-    api.renderer.removePostProcessFn(post)
-  })
-
-  api.route.register([
-    {
-      name: route.screen,
-      render: ({ params }) => <Screen api={api} input={value} route={route} keys={keys} meta={meta} params={params} />,
-    },
-    {
-      name: route.modal,
-      render: ({ params }) => <Modal api={api} input={value} route={route} keys={keys} params={params} />,
-    },
-  ])
-
-  reg(api, value, keys)
-  for (const item of slot(value)) {
-    api.slots.register(item)
-  }
-}
-
-const plugin: TuiPluginModule & { id: string } = {
-  id: "tui-smoke",
-  tui,
-}
-
-export default plugin

.opencode/themes/.gitignore

@@ -1 +0,0 @@
-smoke-theme.json

.opencode/tool/github-pr-search.ts

@@ -1,5 +1,7 @@
 /// <reference path="../env.d.ts" />
 import { tool } from "@opencode-ai/plugin"
+import DESCRIPTION from "./github-pr-search.txt"
+
 async function githubFetch(endpoint: string, options: RequestInit = {}) {
   const response = await fetch(`https://api.github.com${endpoint}`, {
     ...options,
@@ -22,16 +24,7 @@ interface PR {
 }
 
 export default tool({
-  description: `Use this tool to search GitHub pull requests by title and description.
-
-This tool searches PRs in the anomalyco/opencode repository and returns LLM-friendly results including:
-- PR number and title
-- Author
-- State (open/closed/merged)
-- Labels
-- Description snippet
-
-Use the query parameter to search for keywords that might appear in PR titles or descriptions.`,
+  description: DESCRIPTION,
   args: {
     query: tool.schema.string().describe("Search query for PR titles and descriptions"),
     limit: tool.schema.number().describe("Maximum number of results to return").default(10),

.opencode/tool/github-pr-search.txt

@@ -0,0 +1,10 @@
+Use this tool to search GitHub pull requests by title and description.
+
+This tool searches PRs in the sst/opencode repository and returns LLM-friendly results including:
+- PR number and title
+- Author
+- State (open/closed/merged)
+- Labels
+- Description snippet
+
+Use the query parameter to search for keywords that might appear in PR titles or descriptions.

.opencode/tool/github-triage.ts

@@ -1,10 +1,20 @@
 /// <reference path="../env.d.ts" />
 import { tool } from "@opencode-ai/plugin"
+import DESCRIPTION from "./github-triage.txt"
+
 const TEAM = {
   desktop: ["adamdotdevin", "iamdavidhill", "Brendonovich", "nexxeln"],
   zen: ["fwang", "MrMushrooooom"],
-  tui: ["thdxr", "kommander", "rekram1-node"],
-  core: ["thdxr", "rekram1-node", "jlongster"],
+  tui: [
+    "thdxr",
+    "kommander",
+    // "rekram1-node" (on vacation)
+  ],
+  core: [
+    "thdxr",
+    // "rekram1-node", (on vacation)
+    "jlongster",
+  ],
   docs: ["R44VC0RP"],
   windows: ["Hona"],
 } as const
@@ -38,17 +48,9 @@ async function githubFetch(endpoint: string, options: RequestInit = {}) {
 }
 
 export default tool({
-  description: `Use this tool to assign and/or label a GitHub issue.
-
-Choose labels and assignee using the current triage policy and ownership rules.
-Pick the most fitting labels for the issue and assign one owner.
-
-If unsure, choose the team/section with the most overlap with the issue and assign a member from that team at random.`,
+  description: DESCRIPTION,
   args: {
-    assignee: tool.schema
-      .enum(ASSIGNEES as [string, ...string[]])
-      .describe("The username of the assignee")
-      .default("rekram1-node"),
+    assignee: tool.schema.enum(ASSIGNEES as [string, ...string[]]).describe("The username of the assignee"),
     labels: tool.schema
       .array(tool.schema.enum(["nix", "opentui", "perf", "web", "desktop", "zen", "docs", "windows", "core"]))
       .describe("The labels(s) to add to the issue")
@@ -71,7 +73,8 @@ If unsure, choose the team/section with the most overlap with the issue and assi
       results.push("Dropped label: nix (issue does not mention nix)")
     }
 
-    const assignee = nix ? "rekram1-node" : web ? pick(TEAM.desktop) : args.assignee
+    // const assignee = nix ? "rekram1-node" : web ? pick(TEAM.desktop) : args.assignee
+    const assignee = web ? pick(TEAM.desktop) : args.assignee
 
     if (labels.includes("zen") && !zen) {
       throw new Error("Only add the zen label when issue title/body contains 'zen'")

.opencode/tool/github-triage.txt

@@ -0,0 +1,8 @@
+Use this tool to assign and/or label a GitHub issue.
+
+Choose labels and assignee using the current triage policy and ownership rules.
+Pick the most fitting labels for the issue and assign one owner.
+
+If unsure, choose the team/section with the most overlap with the issue and assign a member from that team at random.
+
+(Note: rekram1-node is on vacation, do not assign issues to him.)

.opencode/tui.json

@@ -1,18 +0,0 @@
-{
-  "$schema": "https://opencode.ai/tui.json",
-  "plugin": [
-    [
-      "./plugins/tui-smoke.tsx",
-      {
-        "enabled": false,
-        "label": "workspace",
-        "keybinds": {
-          "modal": "ctrl+alt+m",
-          "screen": "ctrl+alt+o",
-          "home": "escape,ctrl+shift+h",
-          "dialog_close": "escape,q"
-        }
-      }
-    ]
-  ]
-}

.signpath/policies/opencode/test-signing.yml

@@ -0,0 +1,5 @@
+github-policies:
+  runners:
+    allowed_groups:
+      - "GitHub Actions"
+      - "blacksmith runners 01kbd5v56sg8tz7rea39b7ygpt"

AGENTS.md

@@ -1,162 +1,124 @@
-# OpenCode Monorepo Agent Guide
+- To regenerate the JavaScript SDK, run `./packages/sdk/js/script/build.ts`.
+- ALWAYS USE PARALLEL TOOLS WHEN APPLICABLE.
+- The default branch in this repo is `dev`.
+- Local `main` ref may not exist; use `dev` or `origin/dev` for diffs.
+- Prefer automation: execute requested actions without confirmation unless blocked by missing info or safety/irreversibility.
 
-This file is for coding agents working in `/Users/ryanvogel/dev/opencode`.
+## Style Guide
 
-## Scope And Precedence
+### General Principles
 
-- Start with this file for repo-wide defaults.
-- Then check package-local `AGENTS.md` files for stricter rules.
-- Existing local guides include `packages/opencode/AGENTS.md` and `packages/app/AGENTS.md`.
-- Package-specific guides override this file when they conflict.
-
-## Repo Facts
-
-- Package manager: `bun` (`bun@1.3.11`).
-- Monorepo tool: `turbo`.
-- Default branch: `dev`.
-- Root test script intentionally fails; do not run tests from root.
-
-## Cursor / Copilot Rules
-
-- No `.cursor/rules/` directory found.
-- No `.cursorrules` file found.
-- No `.github/copilot-instructions.md` file found.
-- If these files are added later, treat them as mandatory project policy.
-
-## High-Value Commands
-
-Run commands from the correct package directory unless noted.
-
-### Root
-
-- Install deps: `bun install`
-- Run all typechecks via turbo: `bun run typecheck`
-- OpenCode dev CLI entry: `bun run dev`
-- OpenCode serve (common): `bun run dev serve --hostname 0.0.0.0 --port 4096`
-
-### `packages/opencode`
-
-- Dev CLI: `bun run dev`
-- Typecheck: `bun run typecheck`
-- Tests (all): `bun test --timeout 30000`
-- Tests (single file): `bun test test/path/to/file.test.ts --timeout 30000`
-- Tests (single test name): `bun test test/path/to/file.test.ts -t "name fragment" --timeout 30000`
-- Build: `bun run build`
-- Drizzle helper: `bun run db`
-
-### `packages/app`
-
-- Dev server: `bun dev`
-- Build: `bun run build`
-- Typecheck: `bun run typecheck`
-- Unit tests (all): `bun run test:unit`
-- Unit tests (single file): `bun test --preload ./happydom.ts ./src/path/to/file.test.ts`
-- Unit tests (single test name): `bun test --preload ./happydom.ts ./src/path/to/file.test.ts -t "name fragment"`
-- E2E tests: `bun run test:e2e`
-
-### `packages/mobile-voice`
-
-- Start Expo: `bun run start`
-- Start Expo dev client: `bunx expo start --dev-client --clear --host lan`
-- iOS native run: `bun run ios`
-- Android native run: `bun run android`
-- Lint: `bun run lint`
-- Expo doctor: `bunx expo-doctor`
-- Dependency compatibility check: `bunx expo install --check`
-
-### `packages/apn-relay`
-
-- Start relay: `bun run dev`
-- Typecheck: `bun run typecheck`
-- DB connectivity check: `bun run db:check`
-
-## Build / Lint / Test Expectations
-
-- Always run the narrowest checks that prove your change.
-- For backend changes: run package typecheck + relevant tests.
-- For mobile changes: run `expo lint` and at least one `expo` compile-style command if possible.
-- Never claim tests passed unless you ran them in this workspace.
-
-## Single-Test Guidance
-
-- Prefer running one file first, then broaden scope.
-- For Bun tests, pass the file path directly.
-- For name filtering, use `-t "..."`.
-- Keep original timeouts when scripts define them.
-
-## Code Style Guidelines
-
-These conventions are already used heavily in this repo and should be preserved.
-
-### Formatting
-
-- Use Prettier defaults configured in root: `semi: false`, `printWidth: 120`.
-- Keep imports grouped and stable; avoid noisy reorder-only edits.
-- Avoid unrelated formatting churn in touched files.
-
-### Imports
-
-- Prefer explicit imports over dynamic imports unless runtime gating is required.
-- Prefer existing alias patterns (for example `@/...`) where already configured.
-- Do not introduce new dependency layers when a local util already exists.
-
-### Types
-
-- Avoid `any`.
-- Prefer inference for local variables.
-- Add explicit annotations for exported APIs and complex boundaries.
-- Prefer `zod` schemas for request/response validation and parsing.
+- Keep things in one function unless composable or reusable
+- Avoid `try`/`catch` where possible
+- Avoid using the `any` type
+- Prefer single word variable names where possible
+- Use Bun APIs when possible, like `Bun.file()`
+- Rely on type inference when possible; avoid explicit type annotations or interfaces unless necessary for exports or clarity
+- Prefer functional array methods (flatMap, filter, map) over for loops; use type guards on filter to maintain type inference downstream
 
 ### Naming
 
-- Follow existing repo preference for short, clear names.
-- Use single-word names when readable; use multi-word only for clarity.
-- Keep naming consistent with nearby code.
+Prefer single word names for variables and functions. Only use multiple words if necessary.
+
+### Naming Enforcement (Read This)
+
+THIS RULE IS MANDATORY FOR AGENT WRITTEN CODE.
+
+- Use single word names by default for new locals, params, and helper functions.
+- Multi-word names are allowed only when a single word would be unclear or ambiguous.
+- Do not introduce new camelCase compounds when a short single-word alternative is clear.
+- Before finishing edits, review touched lines and shorten newly introduced identifiers where possible.
+- Good short names to prefer: `pid`, `cfg`, `err`, `opts`, `dir`, `root`, `child`, `state`, `timeout`.
+- Examples to avoid unless truly required: `inputPID`, `existingClient`, `connectTimeout`, `workerPath`.
+
+```ts
+// Good
+const foo = 1
+function journal(dir: string) {}
+
+// Bad
+const fooBar = 1
+function prepareJournal(dir: string) {}
+```
+
+Reduce total variable count by inlining when a value is only used once.
+
+```ts
+// Good
+const journal = await Bun.file(path.join(dir, "journal.json")).json()
+
+// Bad
+const journalPath = path.join(dir, "journal.json")
+const journal = await Bun.file(journalPath).json()
+```
+
+### Destructuring
+
+Avoid unnecessary destructuring. Use dot notation to preserve context.
+
+```ts
+// Good
+obj.a
+obj.b
+
+// Bad
+const { a, b } = obj
+```
+
+### Variables
+
+Prefer `const` over `let`. Use ternaries or early returns instead of reassignment.
+
+```ts
+// Good
+const foo = condition ? 1 : 2
+
+// Bad
+let foo
+if (condition) foo = 1
+else foo = 2
+```
 
 ### Control Flow
 
-- Prefer early returns over nested `else` blocks.
-- Keep functions focused; split only when it improves reuse or readability.
+Avoid `else` statements. Prefer early returns.
 
-### Error Handling
+```ts
+// Good
+function foo() {
+  if (condition) return 1
+  return 2
+}
 
-- Fail with actionable messages.
-- Avoid swallowing errors silently.
-- Log enough context to debug production issues (IDs, env, status), but never secrets.
-- In UI code, degrade gracefully for missing capabilities.
+// Bad
+function foo() {
+  if (condition) return 1
+  else return 2
+}
+```
 
-### Data / DB
+### Schema Definitions (Drizzle)
 
-- For Drizzle schema, use snake_case fields and columns.
-- Keep migration and schema changes minimal and explicit.
-- Follow package-specific DB guidance in `packages/opencode/AGENTS.md`.
+Use snake_case for field names so column names don't need to be redefined as strings.
 
-### Testing Philosophy
+```ts
+// Good
+const table = sqliteTable("session", {
+  id: text().primaryKey(),
+  project_id: text().notNull(),
+  created_at: integer().notNull(),
+})
 
-- Prefer testing real behavior over mocks.
-- Add regression tests for bug fixes where practical.
-- Keep fixtures small and focused.
+// Bad
+const table = sqliteTable("session", {
+  id: text("id").primaryKey(),
+  projectID: text("project_id").notNull(),
+  createdAt: integer("created_at").notNull(),
+})
+```
 
-## Agent Workflow Tips
+## Testing
 
-- Read existing code paths before introducing new abstractions.
-- Match local patterns first; do not impose a new style per file.
-- If a package has its own `AGENTS.md`, review it before editing.
-- For OpenCode Effect services, follow `packages/opencode/AGENTS.md` strictly.
-
-## Known Operational Notes
-
-- `packages/app/AGENTS.md` says: never restart app/server processes during that package's debugging workflow.
-- `packages/app/AGENTS.md` also documents local backend+web split for UI work.
-- `packages/opencode/AGENTS.md` contains mandatory Effect and database conventions.
-
-## Regeneration / Special Scripts
-
-- Regenerate JS SDK with: `./packages/sdk/js/script/build.ts`
-
-## Quick Checklist Before Finishing
-
-- Ran relevant package checks.
-- Updated docs/config when behavior changed.
-- Avoided committing unrelated files.
-- Kept edits minimal and aligned with local conventions.
+- Avoid mocks as much as possible
+- Test actual implementation, do not duplicate logic into tests
+- Tests cannot run from repo root (guard: `do-not-run-tests-from-root`); run from package dirs like `packages/opencode`.

README.ar.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.bn.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.br.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.bs.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.da.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.de.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.es.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.fr.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.gr.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.it.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.ja.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.ko.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.no.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.pl.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.ru.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.th.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.tr.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.uk.md

@@ -35,8 +35,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)

README.vi.md

@@ -1,141 +0,0 @@
-<p align="center">
-  <a href="https://opencode.ai">
-    <picture>
-      <source srcset="packages/console/app/src/asset/logo-ornate-dark.svg" media="(prefers-color-scheme: dark)">
-      <source srcset="packages/console/app/src/asset/logo-ornate-light.svg" media="(prefers-color-scheme: light)">
-      <img src="packages/console/app/src/asset/logo-ornate-light.svg" alt="OpenCode logo">
-    </picture>
-  </a>
-</p>
-<p align="center">Trợ lý lập trình AI mã nguồn mở.</p>
-<p align="center">
-  <a href="https://opencode.ai/discord"><img alt="Discord" src="https://img.shields.io/discord/1391832426048651334?style=flat-square&label=discord" /></a>
-  <a href="https://www.npmjs.com/package/opencode-ai"><img alt="npm" src="https://img.shields.io/npm/v/opencode-ai?style=flat-square" /></a>
-  <a href="https://github.com/anomalyco/opencode/actions/workflows/publish.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/anomalyco/opencode/publish.yml?style=flat-square&branch=dev" /></a>
-</p>
-
-<p align="center">
-  <a href="README.md">English</a> |
-  <a href="README.zh.md">简体中文</a> |
-  <a href="README.zht.md">繁體中文</a> |
-  <a href="README.ko.md">한국어</a> |
-  <a href="README.de.md">Deutsch</a> |
-  <a href="README.es.md">Español</a> |
-  <a href="README.fr.md">Français</a> |
-  <a href="README.it.md">Italiano</a> |
-  <a href="README.da.md">Dansk</a> |
-  <a href="README.ja.md">日本語</a> |
-  <a href="README.pl.md">Polski</a> |
-  <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
-  <a href="README.ar.md">العربية</a> |
-  <a href="README.no.md">Norsk</a> |
-  <a href="README.br.md">Português (Brasil)</a> |
-  <a href="README.th.md">ไทย</a> |
-  <a href="README.tr.md">Türkçe</a> |
-  <a href="README.uk.md">Українська</a> |
-  <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
-</p>
-
-[![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)
-
----
-
-### Cài đặt
-
-```bash
-# YOLO
-curl -fsSL https://opencode.ai/install | bash
-
-# Các trình quản lý gói (Package managers)
-npm i -g opencode-ai@latest        # hoặc bun/pnpm/yarn
-scoop install opencode             # Windows
-choco install opencode             # Windows
-brew install anomalyco/tap/opencode # macOS và Linux (khuyên dùng, luôn cập nhật)
-brew install opencode              # macOS và Linux (công thức brew chính thức, ít cập nhật hơn)
-sudo pacman -S opencode            # Arch Linux (Bản ổn định)
-paru -S opencode-bin               # Arch Linux (Bản mới nhất từ AUR)
-mise use -g opencode               # Mọi hệ điều hành
-nix run nixpkgs#opencode           # hoặc github:anomalyco/opencode cho nhánh dev mới nhất
-```
-
-> [!TIP]
-> Hãy xóa các phiên bản cũ hơn 0.1.x trước khi cài đặt.
-
-### Ứng dụng Desktop (BETA)
-
-OpenCode cũng có sẵn dưới dạng ứng dụng desktop. Tải trực tiếp từ [trang releases](https://github.com/anomalyco/opencode/releases) hoặc [opencode.ai/download](https://opencode.ai/download).
-
-| Nền tảng              | Tải xuống                             |
-| --------------------- | ------------------------------------- |
-| macOS (Apple Silicon) | `opencode-desktop-darwin-aarch64.dmg` |
-| macOS (Intel)         | `opencode-desktop-darwin-x64.dmg`     |
-| Windows               | `opencode-desktop-windows-x64.exe`    |
-| Linux                 | `.deb`, `.rpm`, hoặc AppImage         |
-
-```bash
-# macOS (Homebrew)
-brew install --cask opencode-desktop
-# Windows (Scoop)
-scoop bucket add extras; scoop install extras/opencode-desktop
-```
-
-#### Thư mục cài đặt
-
-Tập lệnh cài đặt tuân theo thứ tự ưu tiên sau cho đường dẫn cài đặt:
-
-1. `$OPENCODE_INSTALL_DIR` - Thư mục cài đặt tùy chỉnh
-2. `$XDG_BIN_DIR` - Đường dẫn tuân thủ XDG Base Directory Specification
-3. `$HOME/bin` - Thư mục nhị phân tiêu chuẩn của người dùng (nếu tồn tại hoặc có thể tạo)
-4. `$HOME/.opencode/bin` - Mặc định dự phòng
-
-```bash
-# Ví dụ
-OPENCODE_INSTALL_DIR=/usr/local/bin curl -fsSL https://opencode.ai/install | bash
-XDG_BIN_DIR=$HOME/.local/bin curl -fsSL https://opencode.ai/install | bash
-```
-
-### Agents (Đại diện)
-
-OpenCode bao gồm hai agent được tích hợp sẵn mà bạn có thể chuyển đổi bằng phím `Tab`.
-
-- **build** - Agent mặc định, có toàn quyền truy cập cho công việc lập trình
-- **plan** - Agent chỉ đọc dùng để phân tích và khám phá mã nguồn
-  - Mặc định từ chối việc chỉnh sửa tệp
-  - Hỏi quyền trước khi chạy các lệnh bash
-  - Lý tưởng để khám phá các codebase lạ hoặc lên kế hoạch thay đổi
-
-Ngoài ra còn có một subagent **general** dùng cho các tìm kiếm phức tạp và tác vụ nhiều bước.
-Agent này được sử dụng nội bộ và có thể gọi bằng cách dùng `@general` trong tin nhắn.
-
-Tìm hiểu thêm về [agents](https://opencode.ai/docs/agents).
-
-### Tài liệu
-
-Để biết thêm thông tin về cách cấu hình OpenCode, [**hãy truy cập tài liệu của chúng tôi**](https://opencode.ai/docs).
-
-### Đóng góp
-
-Nếu bạn muốn đóng góp cho OpenCode, vui lòng đọc [tài liệu hướng dẫn đóng góp](./CONTRIBUTING.md) trước khi gửi pull request.
-
-### Xây dựng trên nền tảng OpenCode
-
-Nếu bạn đang làm việc trên một dự án liên quan đến OpenCode và sử dụng "opencode" như một phần của tên dự án, ví dụ "opencode-dashboard" hoặc "opencode-mobile", vui lòng thêm một ghi chú vào README của bạn để làm rõ rằng dự án đó không được xây dựng bởi đội ngũ OpenCode và không liên kết với chúng tôi dưới bất kỳ hình thức nào.
-
-### Các câu hỏi thường gặp (FAQ)
-
-#### OpenCode khác biệt thế nào so với Claude Code?
-
-Về mặt tính năng, nó rất giống Claude Code. Dưới đây là những điểm khác biệt chính:
-
-- 100% mã nguồn mở
-- Không bị ràng buộc với bất kỳ nhà cung cấp nào. Mặc dù chúng tôi khuyên dùng các mô hình được cung cấp qua [OpenCode Zen](https://opencode.ai/zen), OpenCode có thể được sử dụng với Claude, OpenAI, Google, hoặc thậm chí các mô hình chạy cục bộ. Khi các mô hình phát triển, khoảng cách giữa chúng sẽ thu hẹp lại và giá cả sẽ giảm, vì vậy việc không phụ thuộc vào nhà cung cấp là rất quan trọng.
-- Hỗ trợ LSP ngay từ đầu
-- Tập trung vào TUI (Giao diện người dùng dòng lệnh). OpenCode được xây dựng bởi những người dùng neovim và đội ngũ tạo ra [terminal.shop](https://terminal.shop); chúng tôi sẽ đẩy giới hạn của những gì có thể làm được trên terminal lên mức tối đa.
-- Kiến trúc client/server. Chẳng hạn, điều này cho phép OpenCode chạy trên máy tính của bạn trong khi bạn điều khiển nó từ xa qua một ứng dụng di động, nghĩa là frontend TUI chỉ là một trong những client có thể dùng.
-
----
-
-**Tham gia cộng đồng của chúng tôi** [Discord](https://discord.gg/opencode) | [X.com](https://x.com/opencode)

README.zh.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)
@@ -137,4 +135,4 @@ OpenCode 内置两种 Agent，可用 `Tab` 键快速切换：
 
 ---
 
-**加入我们的社区** [飞书](https://applink.feishu.cn/client/chat/chatter/add_by_link?link_token=738j8655-cd59-4633-a30a-1124e0096789&qr_code=true) | [X.com](https://x.com/opencode)
+**加入我们的社区** [Discord](https://discord.gg/opencode) | [X.com](https://x.com/opencode)

README.zht.md

@@ -27,7 +27,6 @@
   <a href="README.ja.md">日本語</a> |
   <a href="README.pl.md">Polski</a> |
   <a href="README.ru.md">Русский</a> |
-  <a href="README.bs.md">Bosanski</a> |
   <a href="README.ar.md">العربية</a> |
   <a href="README.no.md">Norsk</a> |
   <a href="README.br.md">Português (Brasil)</a> |
@@ -35,8 +34,7 @@
   <a href="README.tr.md">Türkçe</a> |
   <a href="README.uk.md">Українська</a> |
   <a href="README.bn.md">বাংলা</a> |
-  <a href="README.gr.md">Ελληνικά</a> |
-  <a href="README.vi.md">Tiếng Việt</a>
+  <a href="README.gr.md">Ελληνικά</a>
 </p>
 
 [![OpenCode Terminal UI](packages/web/src/assets/lander/screenshot.png)](https://opencode.ai)
@@ -137,4 +135,4 @@ OpenCode 內建了兩種 Agent，您可以使用 `Tab` 鍵快速切換。
 
 ---
 
-**加入我們的社群** [飞书](https://applink.feishu.cn/client/chat/chatter/add_by_link?link_token=738j8655-cd59-4633-a30a-1124e0096789&qr_code=true) | [X.com](https://x.com/opencode)
+**加入我們的社群** [Discord](https://discord.gg/opencode) | [X.com](https://x.com/opencode)

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1773909469,
-        "narHash": "sha256-vglVrLfHjFIzIdV9A27Ugul6rh3I1qHbbitGW7dk420=",
+        "lastModified": 1772091128,
+        "narHash": "sha256-TnrYykX8Mf/Ugtkix6V+PjW7miU2yClA6uqWl/v6KWM=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "7149c06513f335be57f26fcbbbe34afda923882b",
+        "rev": "3f0336406035444b4a24b942788334af5f906259",
         "type": "github"
       },
       "original": {

github/index.ts

@@ -8,7 +8,6 @@ import type { Context as GitHubContext } from "@actions/github/lib/context"
 import type { IssueCommentEvent, PullRequestReviewCommentEvent } from "@octokit/webhooks-types"
 import { createOpencodeClient } from "@opencode-ai/sdk"
 import { spawn } from "node:child_process"
-import { setTimeout as sleep } from "node:timers/promises"
 
 type GitHubAuthor = {
   login: string
@@ -282,7 +281,7 @@ async function assertOpencodeConnected() {
       connected = true
       break
     } catch (e) {}
-    await sleep(300)
+    await Bun.sleep(300)
   } while (retry++ < 30)
 
   if (!connected) {
@@ -496,6 +495,7 @@ async function subscribeSessionEvents() {
 
   const TOOL: Record<string, [string, string]> = {
     todowrite: ["Todo", "\x1b[33m\x1b[1m"],
+    todoread: ["Todo", "\x1b[33m\x1b[1m"],
     bash: ["Bash", "\x1b[31m\x1b[1m"],
     edit: ["Edit", "\x1b[32m\x1b[1m"],
     glob: ["Glob", "\x1b[34m\x1b[1m"],

infra/console.ts

@@ -103,12 +103,6 @@ export const stripeWebhook = new stripe.WebhookEndpoint("StripeWebhookEndpoint",
 const zenLiteProduct = new stripe.Product("ZenLite", {
   name: "OpenCode Go",
 })
-const zenLiteCouponFirstMonth50 = new stripe.Coupon("ZenLiteCouponFirstMonth50", {
-  name: "First month 50% off",
-  percentOff: 50,
-  appliesToProducts: [zenLiteProduct.id],
-  duration: "once",
-})
 const zenLitePrice = new stripe.Price("ZenLitePrice", {
   product: zenLiteProduct.id,
   currency: "usd",
@@ -122,8 +116,6 @@ const ZEN_LITE_PRICE = new sst.Linkable("ZEN_LITE_PRICE", {
   properties: {
     product: zenLiteProduct.id,
     price: zenLitePrice.id,
-    priceInr: 92900,
-    firstMonth50Coupon: zenLiteCouponFirstMonth50.id,
   },
 })
 
@@ -202,10 +194,6 @@ const bucketNew = new sst.cloudflare.Bucket("ZenDataNew")
 const AWS_SES_ACCESS_KEY_ID = new sst.Secret("AWS_SES_ACCESS_KEY_ID")
 const AWS_SES_SECRET_ACCESS_KEY = new sst.Secret("AWS_SES_SECRET_ACCESS_KEY")
 
-const SALESFORCE_CLIENT_ID = new sst.Secret("SALESFORCE_CLIENT_ID")
-const SALESFORCE_CLIENT_SECRET = new sst.Secret("SALESFORCE_CLIENT_SECRET")
-const SALESFORCE_INSTANCE_URL = new sst.Secret("SALESFORCE_INSTANCE_URL")
-
 const logProcessor = new sst.cloudflare.Worker("LogProcessor", {
   handler: "packages/console/function/src/log-processor.ts",
   link: [new sst.Secret("HONEYCOMB_API_KEY")],
@@ -224,9 +212,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     EMAILOCTOPUS_API_KEY,
     AWS_SES_ACCESS_KEY_ID,
     AWS_SES_SECRET_ACCESS_KEY,
-    SALESFORCE_CLIENT_ID,
-    SALESFORCE_CLIENT_SECRET,
-    SALESFORCE_INSTANCE_URL,
     ZEN_BLACK_PRICE,
     ZEN_LITE_PRICE,
     new sst.Secret("ZEN_LIMITS"),

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-5VHEo9GCBP+MeLMoWqSuJLAX/qwGLdFjZe20yatgogM=",
-    "aarch64-linux": "sha256-hn+V2UpoCj1ddKcq1ySGOMRVvsd3T8sqgpd6nHYfUoA=",
-    "aarch64-darwin": "sha256-Qctkv6AHDrl+qdB1L+DeqLREeWm6BQqtVCK4tibIMCc=",
-    "x86_64-darwin": "sha256-YHHnow2dqtKOsjQvbyKk6HQmTo8cAv8frgOfD5aS3h8="
+    "x86_64-linux": "sha256-8jEwsY7X7N/vKKbVZ0L8Djj2SfH9HCY+2jKSlaCrm9o=",
+    "aarch64-linux": "sha256-L0G7mSzzR+sZW0uACosJGsE2y/Uh3Vi4piXL4UJOmCw=",
+    "aarch64-darwin": "sha256-1S/g/51MSHjDfsL+U8wlt9Rl50hFf7I3fHgbhSqBIP4=",
+    "x86_64-darwin": "sha256-cveFpKVwcrUOzomU4J3wgYEKRwmJQF0KQiRqKgLJqWs="
   }
 }

package.json

@@ -4,12 +4,11 @@
   "description": "AI-powered development tool",
   "private": true,
   "type": "module",
-  "packageManager": "bun@1.3.11",
+  "packageManager": "bun@1.3.10",
   "scripts": {
     "dev": "bun run --cwd packages/opencode --conditions=browser src/index.ts",
     "dev:desktop": "bun --cwd packages/desktop tauri dev",
     "dev:web": "bun --cwd packages/app dev",
-    "dev:console": "ulimit -n 10240 2>/dev/null; bun run --cwd packages/console/app dev",
     "dev:storybook": "bun --cwd packages/storybook storybook",
     "typecheck": "bun turbo typecheck",
     "prepare": "husky",
@@ -25,8 +24,7 @@
       "packages/slack"
     ],
     "catalog": {
-      "@effect/platform-node": "4.0.0-beta.42",
-      "@types/bun": "1.3.11",
+      "@types/bun": "1.3.9",
       "@octokit/rest": "22.0.0",
       "@hono/zod-validator": "0.4.2",
       "ulid": "3.0.1",
@@ -43,17 +41,15 @@
       "@tailwindcss/vite": "4.1.11",
       "diff": "8.0.2",
       "dompurify": "3.3.1",
-      "drizzle-kit": "1.0.0-beta.19-d95b7a4",
-      "drizzle-orm": "1.0.0-beta.19-d95b7a4",
-      "effect": "4.0.0-beta.42",
-      "ai": "6.0.138",
+      "drizzle-kit": "1.0.0-beta.12-a5629fb",
+      "drizzle-orm": "1.0.0-beta.12-a5629fb",
+      "ai": "5.0.124",
       "hono": "4.10.7",
       "hono-openapi": "1.1.2",
       "fuzzysort": "3.1.0",
       "luxon": "3.6.1",
       "marked": "17.0.1",
       "marked-shiki": "1.2.1",
-      "remend": "1.3.0",
       "@playwright/test": "1.51.0",
       "typescript": "5.8.2",
       "@typescript/native-preview": "7.0.0-dev.20251207.1",
@@ -75,13 +71,12 @@
     "@actions/artifact": "5.0.1",
     "@tsconfig/bun": "catalog:",
     "@types/mime-types": "3.0.1",
-    "@typescript/native-preview": "catalog:",
     "glob": "13.0.5",
     "husky": "9.1.7",
     "prettier": "3.6.2",
     "semver": "^7.6.0",
     "sst": "3.18.10",
-    "turbo": "2.8.13"
+    "turbo": "2.5.6"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.933.0",
@@ -104,8 +99,7 @@
     "protobufjs",
     "tree-sitter",
     "tree-sitter-bash",
-    "web-tree-sitter",
-    "electron"
+    "web-tree-sitter"
   ],
   "overrides": {
     "@types/bun": "catalog:",
@@ -113,8 +107,6 @@
   },
   "patchedDependencies": {
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
-    "solid-js@1.9.10": "patches/solid-js@1.9.10.patch",
-    "@ai-sdk/provider-utils@4.0.21": "patches/@ai-sdk%2Fprovider-utils@4.0.21.patch",
-    "@ai-sdk/anthropic@3.0.64": "patches/@ai-sdk%2Fanthropic@3.0.64.patch"
+    "@openrouter/ai-sdk-provider@1.5.4": "patches/@openrouter%2Fai-sdk-provider@1.5.4.patch"
   }
 }

packages/apn-relay/.env.example

@@ -1,11 +0,0 @@
-PORT=8787
-
-DATABASE_HOST=
-DATABASE_USERNAME=
-DATABASE_PASSWORD=
-DATABASE_NAME=main
-
-APNS_TEAM_ID=
-APNS_KEY_ID=
-APNS_PRIVATE_KEY=
-APNS_DEFAULT_BUNDLE_ID=com.anomalyco.mobilevoice

packages/apn-relay/AGENTS.md

@@ -1,106 +0,0 @@
-# apn-relay Agent Guide
-
-This file defines package-specific guidance for agents working in `packages/apn-relay`.
-
-## Scope And Precedence
-
-- Follow root `AGENTS.md` first.
-- This file provides stricter package-level conventions for relay service work.
-- If future local guides are added, closest guide wins.
-
-## Project Overview
-
-- Minimal APNs relay service (Hono + Bun + PlanetScale via Drizzle).
-- Core routes:
-  - `GET /health`
-  - `GET /`
-  - `POST /v1/device/register`
-  - `POST /v1/device/unregister`
-  - `POST /v1/event`
-
-## Commands
-
-Run all commands from `packages/apn-relay`.
-
-- Install deps: `bun install`
-- Start relay locally: `bun run dev`
-- Typecheck: `bun run typecheck`
-- DB connectivity check: `bun run db:check`
-
-## Build / Test Expectations
-
-- There is no dedicated package test script currently.
-- Required validation for behavior changes:
-  - `bun run typecheck`
-  - `bun run db:check` when DB/env changes are involved
-  - manual endpoint verification against `/health`, `/v1/device/register`, `/v1/event`
-
-## Single-Test Guidance
-
-- No single-test command exists for this package today.
-- For focused checks, run endpoint-level manual tests against a local dev server.
-
-## Code Style Guidelines
-
-### Formatting / Structure
-
-- Keep handlers compact and explicit.
-- Prefer small local helpers for repeated route logic.
-- Avoid broad refactors when a targeted fix is enough.
-
-### Types / Validation
-
-- Validate request bodies with `zod` at route boundaries.
-- Keep payload and DB row shapes explicit and close to usage.
-- Avoid `any`; narrow unknown input immediately after parsing.
-
-### Naming
-
-- Follow existing concise naming in this package (`reg`, `unreg`, `evt`, `row`, `key`).
-- For DB columns, keep snake_case alignment with schema.
-
-### Error Handling
-
-- Return clear JSON errors for invalid input.
-- Keep handler failures observable via `app.onError` and structured logs.
-- Do not leak secrets in responses or logs.
-
-### Logging
-
-- Log delivery lifecycle at key checkpoints:
-  - registration/unregistration attempts
-  - event fanout start/end
-  - APNs send failures and retries
-- Mask sensitive values; prefer token suffixes and metadata.
-
-### APNs Environment Rules
-
-- Keep APNs env explicit per registration (`sandbox` / `production`).
-- For `BadEnvironmentKeyInToken`, retry once with flipped env and persist correction.
-- Avoid infinite retry loops; one retry max per delivery attempt.
-
-## Database Conventions
-
-- Schema is in `src/schema.sql.ts`.
-- Keep table/column names snake_case.
-- Maintain index naming consistency with existing schema.
-- For upserts, update only fields required by current behavior.
-
-## API Behavior Expectations
-
-- `register`/`unregister` must be idempotent.
-- `event` should return success envelope even when no devices are registered.
-- Delivery logs should capture per-attempt result and error payload.
-
-## Operational Notes
-
-- Ensure `APNS_PRIVATE_KEY` supports escaped newline format (`\n`) and raw multiline.
-- Validate that `APNS_DEFAULT_BUNDLE_ID` matches mobile app bundle identifier.
-- Avoid coupling route behavior to deployment platform specifics.
-
-## Before Finishing
-
-- Run `bun run typecheck`.
-- If DB/env behavior changed, run `bun run db:check`.
-- Manually exercise affected endpoints.
-- Confirm logs are useful and secret-safe.

packages/apn-relay/Dockerfile

@@ -1,14 +0,0 @@
-FROM oven/bun:1.3.11-alpine
-
-WORKDIR /app
-
-COPY package.json ./
-COPY tsconfig.json ./
-COPY drizzle.config.ts ./
-RUN bun install --production
-
-COPY src ./src
-
-EXPOSE 8787
-
-CMD ["bun", "run", "src/index.ts"]

packages/apn-relay/README.md

@@ -1,46 +0,0 @@
-# APN Relay
-
-Minimal APNs relay for OpenCode mobile background notifications.
-
-## What it does
-
-- Registers iOS device tokens for a shared secret.
-- Receives OpenCode event posts (`complete`, `permission`, `error`).
-- Sends APNs notifications to mapped devices.
-- Stores delivery rows in PlanetScale.
-
-## Routes
-
-- `GET /health`
-- `GET /` (simple dashboard)
-- `POST /v1/device/register`
-- `POST /v1/device/unregister`
-- `POST /v1/event`
-
-## Environment
-
-Use `.env.example` as a starting point.
-
-- `DATABASE_HOST`
-- `DATABASE_USERNAME`
-- `DATABASE_PASSWORD`
-- `APNS_TEAM_ID`
-- `APNS_KEY_ID`
-- `APNS_PRIVATE_KEY`
-- `APNS_DEFAULT_BUNDLE_ID`
-
-## Run locally
-
-```bash
-bun install
-bun run src/index.ts
-```
-
-## Docker
-
-Build from this directory:
-
-```bash
-docker build -t apn-relay .
-docker run --rm -p 8787:8787 --env-file .env apn-relay
-```

packages/apn-relay/drizzle.config.ts

@@ -1,17 +0,0 @@
-import { defineConfig } from "drizzle-kit"
-
-export default defineConfig({
-  out: "./migration",
-  strict: true,
-  schema: ["./src/**/*.sql.ts"],
-  dialect: "mysql",
-  dbCredentials: {
-    host: process.env.DATABASE_HOST ?? "",
-    user: process.env.DATABASE_USERNAME ?? "",
-    password: process.env.DATABASE_PASSWORD ?? "",
-    database: process.env.DATABASE_NAME ?? "main",
-    ssl: {
-      rejectUnauthorized: false,
-    },
-  },
-})

packages/apn-relay/package.json

@@ -1,27 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/package.json",
-  "name": "@opencode-ai/apn-relay",
-  "version": "0.0.0",
-  "private": true,
-  "type": "module",
-  "license": "MIT",
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "db:check": "bun run --env-file .env src/check.ts",
-    "typecheck": "tsgo --noEmit"
-  },
-  "dependencies": {
-    "@planetscale/database": "1.19.0",
-    "drizzle-orm": "1.0.0-beta.19-d95b7a4",
-    "hono": "4.10.7",
-    "jose": "6.0.11",
-    "zod": "4.1.8"
-  },
-  "devDependencies": {
-    "@tsconfig/bun": "1.0.9",
-    "@types/bun": "1.3.11",
-    "@typescript/native-preview": "7.0.0-dev.20251207.1",
-    "drizzle-kit": "1.0.0-beta.19-d95b7a4",
-    "typescript": "5.8.2"
-  }
-}

packages/apn-relay/src/apns.ts

@@ -1,148 +0,0 @@
-import { connect } from "node:http2"
-import { SignJWT, importPKCS8 } from "jose"
-import { env } from "./env"
-
-export type PushEnv = "sandbox" | "production"
-
-type PushInput = {
-  token: string
-  bundle: string
-  env: PushEnv
-  title: string
-  body: string
-  data: Record<string, unknown>
-}
-
-type PushResult = {
-  ok: boolean
-  code: number
-  error?: string
-}
-
-let jwt = ""
-let exp = 0
-let pk: Awaited<ReturnType<typeof importPKCS8>> | undefined
-
-function host(input: PushEnv) {
-  if (input === "sandbox") return "api.sandbox.push.apple.com"
-  return "api.push.apple.com"
-}
-
-function key() {
-  if (env.APNS_PRIVATE_KEY.includes("\\n")) return env.APNS_PRIVATE_KEY.replace(/\\n/g, "\n")
-  return env.APNS_PRIVATE_KEY
-}
-
-async function sign() {
-  if (!pk) pk = await importPKCS8(key(), "ES256")
-  const now = Math.floor(Date.now() / 1000)
-  if (jwt && now < exp) return jwt
-  jwt = await new SignJWT({})
-    .setProtectedHeader({ alg: "ES256", kid: env.APNS_KEY_ID })
-    .setIssuer(env.APNS_TEAM_ID)
-    .setIssuedAt(now)
-    .sign(pk)
-  exp = now + 50 * 60
-  return jwt
-}
-
-function post(input: {
-  host: string
-  token: string
-  auth: string
-  bundle: string
-  payload: string
-}): Promise<{ code: number; body: string }> {
-  return new Promise((resolve, reject) => {
-    const cli = connect(`https://${input.host}`)
-    let done = false
-    let code = 0
-    let body = ""
-
-    const stop = (fn: () => void) => {
-      if (done) return
-      done = true
-      fn()
-    }
-
-    cli.on("error", (err) => {
-      stop(() => reject(err))
-      cli.close()
-    })
-
-    const req = cli.request({
-      ":method": "POST",
-      ":path": `/3/device/${input.token}`,
-      authorization: `bearer ${input.auth}`,
-      "apns-topic": input.bundle,
-      "apns-push-type": "alert",
-      "apns-priority": "10",
-      "content-type": "application/json",
-    })
-
-    req.setEncoding("utf8")
-    req.on("response", (headers) => {
-      code = Number(headers[":status"] ?? 0)
-    })
-    req.on("data", (chunk) => {
-      body += chunk
-    })
-    req.on("end", () => {
-      stop(() => resolve({ code, body }))
-      cli.close()
-    })
-    req.on("error", (err) => {
-      stop(() => reject(err))
-      cli.close()
-    })
-    req.end(input.payload)
-  })
-}
-
-export async function send(input: PushInput): Promise<PushResult> {
-  const auth = await sign().catch((err) => {
-    return `error:${String(err)}`
-  })
-  if (auth.startsWith("error:")) {
-    return {
-      ok: false,
-      code: 0,
-      error: auth,
-    }
-  }
-
-  const payload = JSON.stringify({
-    aps: {
-      alert: {
-        title: input.title,
-        body: input.body,
-      },
-      sound: "default",
-    },
-    ...input.data,
-  })
-
-  const out = await post({
-    host: host(input.env),
-    token: input.token,
-    auth,
-    bundle: input.bundle,
-    payload,
-  }).catch((err) => ({
-    code: 0,
-    body: String(err),
-  }))
-
-  if (out.code === 200) {
-    return {
-      ok: true,
-      code: 200,
-    }
-  }
-
-  return {
-    ok: false,
-    code: out.code,
-    error: out.body,
-  }
-}

packages/apn-relay/src/check.ts

@@ -1,28 +0,0 @@
-import { sql } from "drizzle-orm"
-import { db } from "./db"
-import { env } from "./env"
-import { delivery_log, device_registration } from "./schema.sql"
-import { setup } from "./setup"
-
-async function run() {
-  console.log(`[apn-relay] DB host: ${env.DATABASE_HOST}`)
-
-  await db.execute(sql`SELECT 1`)
-  console.log("[apn-relay] DB connection OK")
-
-  await setup()
-  console.log("[apn-relay] Setup migration OK")
-
-  const [a] = await db.select({ value: sql<number>`count(*)` }).from(device_registration)
-  const [b] = await db.select({ value: sql<number>`count(*)` }).from(delivery_log)
-
-  console.log(`[apn-relay] device_registration rows: ${Number(a?.value ?? 0)}`)
-  console.log(`[apn-relay] delivery_log rows: ${Number(b?.value ?? 0)}`)
-  console.log("[apn-relay] DB check passed")
-}
-
-run().catch((err) => {
-  console.error("[apn-relay] DB check failed")
-  console.error(err)
-  process.exit(1)
-})

packages/apn-relay/src/db.ts

@@ -1,11 +0,0 @@
-import { Client } from "@planetscale/database"
-import { drizzle } from "drizzle-orm/planetscale-serverless"
-import { env } from "./env"
-
-const client = new Client({
-  host: env.DATABASE_HOST,
-  username: env.DATABASE_USERNAME,
-  password: env.DATABASE_PASSWORD,
-})
-
-export const db = drizzle({ client })

packages/apn-relay/src/env.ts

@@ -1,47 +0,0 @@
-import { z } from "zod"
-
-const bad = new Set(["undefined", "null"])
-const txt = z
-  .string()
-  .transform((input) => input.trim())
-  .refine((input) => input.length > 0 && !bad.has(input.toLowerCase()))
-
-const schema = z.object({
-  PORT: z.coerce.number().int().positive().default(8787),
-  DATABASE_HOST: txt,
-  DATABASE_USERNAME: txt,
-  DATABASE_PASSWORD: txt,
-  APNS_TEAM_ID: txt,
-  APNS_KEY_ID: txt,
-  APNS_PRIVATE_KEY: txt,
-  APNS_DEFAULT_BUNDLE_ID: txt,
-})
-
-const req = [
-  "DATABASE_HOST",
-  "DATABASE_USERNAME",
-  "DATABASE_PASSWORD",
-  "APNS_TEAM_ID",
-  "APNS_KEY_ID",
-  "APNS_PRIVATE_KEY",
-  "APNS_DEFAULT_BUNDLE_ID",
-] as const
-
-const out = schema.safeParse(process.env)
-
-if (!out.success) {
-  const miss = req.filter((key) => !process.env[key]?.trim())
-  const bad = out.error.issues
-    .map((item) => item.path[0])
-    .filter((key): key is string => typeof key === "string")
-    .filter((key) => !miss.includes(key as (typeof req)[number]))
-
-  console.error("[apn-relay] Invalid startup configuration")
-  if (miss.length) console.error(`[apn-relay] Missing required env vars: ${miss.join(", ")}`)
-  if (bad.length) console.error(`[apn-relay] Invalid env vars: ${Array.from(new Set(bad)).join(", ")}`)
-  console.error("[apn-relay] Check .env.example and restart")
-
-  throw new Error("Startup configuration invalid")
-}
-
-export const env = out.data

packages/apn-relay/src/hash.ts

@@ -1,5 +0,0 @@
-import { createHash } from "node:crypto"
-
-export function hash(input: string) {
-  return createHash("sha256").update(input).digest("hex")
-}

packages/apn-relay/src/index.ts

@@ -1,436 +0,0 @@
-import { randomUUID } from "node:crypto"
-import { and, desc, eq, sql } from "drizzle-orm"
-import { Hono } from "hono"
-import { z } from "zod"
-import { send } from "./apns"
-import { db } from "./db"
-import { env } from "./env"
-import { hash } from "./hash"
-import { delivery_log, device_registration } from "./schema.sql"
-import { setup } from "./setup"
-
-function bad(input?: string) {
-  if (!input) return false
-  return input.includes("BadEnvironmentKeyInToken")
-}
-
-function flip(input: "sandbox" | "production") {
-  if (input === "sandbox") return "production"
-  return "sandbox"
-}
-
-function tail(input: string) {
-  return input.slice(-8)
-}
-
-function esc(input: unknown) {
-  return String(input ?? "")
-    .replaceAll("&", "&")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;")
-    .replaceAll("'", "&#39;")
-}
-
-function fmt(input: number) {
-  return new Date(input).toISOString()
-}
-
-const reg = z.object({
-  secret: z.string().min(1),
-  deviceToken: z.string().min(1),
-  bundleId: z.string().min(1).optional(),
-  apnsEnv: z.enum(["sandbox", "production"]).default("production"),
-})
-
-const unreg = z.object({
-  secret: z.string().min(1),
-  deviceToken: z.string().min(1),
-})
-
-const evt = z.object({
-  secret: z.string().min(1),
-  eventType: z.enum(["complete", "permission", "error"]),
-  sessionID: z.string().min(1),
-  title: z.string().min(1).optional(),
-  body: z.string().min(1).optional(),
-})
-
-function title(input: z.infer<typeof evt>["eventType"]) {
-  if (input === "complete") return "Session complete"
-  if (input === "permission") return "Action needed"
-  return "Session error"
-}
-
-function body(input: z.infer<typeof evt>["eventType"]) {
-  if (input === "complete") return "OpenCode finished your session."
-  if (input === "permission") return "OpenCode needs your permission decision."
-  return "OpenCode reported an error for your session."
-}
-
-const app = new Hono()
-
-app.onError((err, c) => {
-  return c.json(
-    {
-      ok: false,
-      error: err.message,
-    },
-    500,
-  )
-})
-
-app.notFound((c) => {
-  return c.json(
-    {
-      ok: false,
-      error: "Not found",
-    },
-    404,
-  )
-})
-
-app.get("/health", async (c) => {
-  const [a] = await db.select({ value: sql<number>`count(*)` }).from(device_registration)
-  const [b] = await db.select({ value: sql<number>`count(*)` }).from(delivery_log)
-  return c.json({
-    ok: true,
-    devices: Number(a?.value ?? 0),
-    deliveries: Number(b?.value ?? 0),
-  })
-})
-
-app.get("/", async (c) => {
-  const [a] = await db.select({ value: sql<number>`count(*)` }).from(device_registration)
-  const [b] = await db.select({ value: sql<number>`count(*)` }).from(delivery_log)
-  const devices = await db.select().from(device_registration).orderBy(desc(device_registration.updated_at)).limit(100)
-  const byBundle = await db
-    .select({
-      bundle: device_registration.bundle_id,
-      env: device_registration.apns_env,
-      value: sql<number>`count(*)`,
-    })
-    .from(device_registration)
-    .groupBy(device_registration.bundle_id, device_registration.apns_env)
-    .orderBy(desc(sql<number>`count(*)`))
-  const rows = await db.select().from(delivery_log).orderBy(desc(delivery_log.created_at)).limit(20)
-
-  const html = `<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>APN Relay</title>
-    <style>
-      body { font-family: ui-sans-serif, system-ui, sans-serif; margin: 24px; color: #111827; }
-      h1 { margin: 0 0 12px 0; }
-      h2 { margin: 22px 0 10px 0; font-size: 16px; }
-      .stats { display: flex; gap: 16px; margin: 0 0 18px 0; }
-      .card { border: 1px solid #e5e7eb; border-radius: 8px; padding: 10px 12px; min-width: 160px; }
-      .muted { color: #6b7280; font-size: 12px; }
-      .small { font-size: 11px; color: #6b7280; }
-      table { border-collapse: collapse; width: 100%; }
-      th, td { border: 1px solid #e5e7eb; text-align: left; padding: 8px; font-size: 12px; }
-      th { background: #f9fafb; }
-    </style>
-  </head>
-  <body>
-    <h1>APN Relay</h1>
-    <p class="muted">MVP dashboard</p>
-    <div class="stats">
-      <div class="card">
-        <div class="muted">Registered devices</div>
-        <div>${Number(a?.value ?? 0)}</div>
-      </div>
-      <div class="card">
-        <div class="muted">Delivery log rows</div>
-        <div>${Number(b?.value ?? 0)}</div>
-      </div>
-    </div>
-    <h2>Registered devices</h2>
-    <p class="small">Most recent 100 registrations. Token values are masked to suffix only.</p>
-    <table>
-      <thead>
-        <tr>
-          <th>updated</th>
-          <th>created</th>
-          <th>token suffix</th>
-          <th>env</th>
-          <th>bundle</th>
-          <th>secret hash</th>
-        </tr>
-      </thead>
-      <tbody>
-        ${
-          devices.length
-            ? devices
-                .map(
-                  (row) => `<tr>
-          <td>${esc(fmt(row.updated_at))}</td>
-          <td>${esc(fmt(row.created_at))}</td>
-          <td>${esc(tail(row.device_token))}</td>
-          <td>${esc(row.apns_env)}</td>
-          <td>${esc(row.bundle_id)}</td>
-          <td>${esc(`${row.secret_hash.slice(0, 12)}…`)}</td>
-        </tr>`,
-                )
-                .join("")
-            : `<tr><td colspan="6" class="muted">No devices registered.</td></tr>`
-        }
-      </tbody>
-    </table>
-    <h2>Bundle breakdown</h2>
-    <table>
-      <thead>
-        <tr>
-          <th>bundle</th>
-          <th>env</th>
-          <th>count</th>
-        </tr>
-      </thead>
-      <tbody>
-        ${
-          byBundle.length
-            ? byBundle
-                .map(
-                  (row) => `<tr>
-          <td>${esc(row.bundle)}</td>
-          <td>${esc(row.env)}</td>
-          <td>${esc(Number(row.value ?? 0))}</td>
-        </tr>`,
-                )
-                .join("")
-            : `<tr><td colspan="3" class="muted">No device data.</td></tr>`
-        }
-      </tbody>
-    </table>
-    <h2>Recent deliveries</h2>
-    <table>
-      <thead>
-        <tr>
-          <th>time</th>
-          <th>event</th>
-          <th>session</th>
-          <th>status</th>
-          <th>error</th>
-        </tr>
-      </thead>
-      <tbody>
-        ${rows
-          .map(
-            (row) => `<tr>
-          <td>${esc(fmt(row.created_at))}</td>
-          <td>${esc(row.event_type)}</td>
-          <td>${esc(row.session_id)}</td>
-          <td>${esc(row.status)}</td>
-          <td>${esc(row.error ?? "")}</td>
-        </tr>`,
-          )
-          .join("")}
-      </tbody>
-    </table>
-  </body>
-</html>`
-
-  return c.html(html)
-})
-
-app.post("/v1/device/register", async (c) => {
-  const raw = await c.req.json().catch(() => undefined)
-  const check = reg.safeParse(raw)
-  if (!check.success) {
-    return c.json(
-      {
-        ok: false,
-        error: "Invalid request body",
-      },
-      400,
-    )
-  }
-
-  const now = Date.now()
-  const key = hash(check.data.secret)
-  const row = {
-    id: randomUUID(),
-    secret_hash: key,
-    device_token: check.data.deviceToken,
-    bundle_id: check.data.bundleId ?? env.APNS_DEFAULT_BUNDLE_ID,
-    apns_env: check.data.apnsEnv,
-    created_at: now,
-    updated_at: now,
-  }
-
-  console.log("[relay] register", {
-    token: tail(row.device_token),
-    env: row.apns_env,
-    bundle: row.bundle_id,
-  })
-
-  await db
-    .insert(device_registration)
-    .values(row)
-    .onDuplicateKeyUpdate({
-      set: {
-        bundle_id: row.bundle_id,
-        apns_env: row.apns_env,
-        updated_at: now,
-      },
-    })
-
-  return c.json({ ok: true })
-})
-
-app.post("/v1/device/unregister", async (c) => {
-  const raw = await c.req.json().catch(() => undefined)
-  const check = unreg.safeParse(raw)
-  if (!check.success) {
-    return c.json(
-      {
-        ok: false,
-        error: "Invalid request body",
-      },
-      400,
-    )
-  }
-
-  console.log("[relay] unregister", {
-    token: tail(check.data.deviceToken),
-  })
-
-  await db
-    .delete(device_registration)
-    .where(
-      and(
-        eq(device_registration.secret_hash, hash(check.data.secret)),
-        eq(device_registration.device_token, check.data.deviceToken),
-      ),
-    )
-
-  return c.json({ ok: true })
-})
-
-app.post("/v1/event", async (c) => {
-  const raw = await c.req.json().catch(() => undefined)
-  const check = evt.safeParse(raw)
-  if (!check.success) {
-    return c.json(
-      {
-        ok: false,
-        error: "Invalid request body",
-      },
-      400,
-    )
-  }
-
-  const key = hash(check.data.secret)
-  const list = await db.select().from(device_registration).where(eq(device_registration.secret_hash, key))
-  console.log("[relay] event", {
-    type: check.data.eventType,
-    session: check.data.sessionID,
-    devices: list.length,
-  })
-  if (!list.length) {
-    return c.json({
-      ok: true,
-      sent: 0,
-      failed: 0,
-    })
-  }
-
-  const out = await Promise.all(
-    list.map(async (row) => {
-      const env = row.apns_env === "sandbox" ? "sandbox" : "production"
-      const payload = {
-        token: row.device_token,
-        bundle: row.bundle_id,
-        title: check.data.title ?? title(check.data.eventType),
-        body: check.data.body ?? body(check.data.eventType),
-        data: {
-          eventType: check.data.eventType,
-          sessionID: check.data.sessionID,
-        },
-      }
-      const first = await send({ ...payload, env })
-      if (first.ok || !bad(first.error)) {
-        if (!first.ok) {
-          console.log("[relay] send:error", {
-            token: tail(row.device_token),
-            env,
-            error: first.error,
-          })
-        }
-        return first
-      }
-
-      const alt = flip(env)
-      console.log("[relay] send:retry-env", {
-        token: tail(row.device_token),
-        from: env,
-        to: alt,
-      })
-      const second = await send({ ...payload, env: alt })
-      if (!second.ok) {
-        console.log("[relay] send:error", {
-          token: tail(row.device_token),
-          env: alt,
-          error: second.error,
-        })
-        return second
-      }
-
-      await db
-        .update(device_registration)
-        .set({ apns_env: alt, updated_at: Date.now() })
-        .where(
-          and(
-            eq(device_registration.secret_hash, row.secret_hash),
-            eq(device_registration.device_token, row.device_token),
-          ),
-        )
-
-      console.log("[relay] send:env-updated", {
-        token: tail(row.device_token),
-        env: alt,
-      })
-      return second
-    }),
-  )
-
-  const now = Date.now()
-  await db.insert(delivery_log).values(
-    out.map((item) => ({
-      id: randomUUID(),
-      secret_hash: key,
-      event_type: check.data.eventType,
-      session_id: check.data.sessionID,
-      status: item.ok ? "sent" : "failed",
-      error: item.error,
-      created_at: now,
-    })),
-  )
-
-  const sent = out.filter((item) => item.ok).length
-  console.log("[relay] event:done", {
-    type: check.data.eventType,
-    session: check.data.sessionID,
-    sent,
-    failed: out.length - sent,
-  })
-  return c.json({
-    ok: true,
-    sent,
-    failed: out.length - sent,
-  })
-})
-
-await setup()
-
-if (import.meta.main) {
-  Bun.serve({
-    port: env.PORT,
-    fetch: app.fetch,
-  })
-  console.log(`apn-relay listening on http://0.0.0.0:${env.PORT}`)
-}
-
-export { app }

packages/apn-relay/src/schema.sql.ts

@@ -1,35 +0,0 @@
-import { bigint, index, mysqlTable, uniqueIndex, varchar } from "drizzle-orm/mysql-core"
-
-export const device_registration = mysqlTable(
-  "device_registration",
-  {
-    id: varchar("id", { length: 36 }).primaryKey(),
-    secret_hash: varchar("secret_hash", { length: 64 }).notNull(),
-    device_token: varchar("device_token", { length: 255 }).notNull(),
-    bundle_id: varchar("bundle_id", { length: 255 }).notNull(),
-    apns_env: varchar("apns_env", { length: 16 }).notNull().default("production"),
-    created_at: bigint("created_at", { mode: "number" }).notNull(),
-    updated_at: bigint("updated_at", { mode: "number" }).notNull(),
-  },
-  (table) => [
-    uniqueIndex("device_registration_secret_token_idx").on(table.secret_hash, table.device_token),
-    index("device_registration_secret_hash_idx").on(table.secret_hash),
-  ],
-)
-
-export const delivery_log = mysqlTable(
-  "delivery_log",
-  {
-    id: varchar("id", { length: 36 }).primaryKey(),
-    secret_hash: varchar("secret_hash", { length: 64 }).notNull(),
-    event_type: varchar("event_type", { length: 32 }).notNull(),
-    session_id: varchar("session_id", { length: 255 }).notNull(),
-    status: varchar("status", { length: 16 }).notNull(),
-    error: varchar("error", { length: 1024 }),
-    created_at: bigint("created_at", { mode: "number" }).notNull(),
-  },
-  (table) => [
-    index("delivery_log_secret_hash_idx").on(table.secret_hash),
-    index("delivery_log_created_at_idx").on(table.created_at),
-  ],
-)

packages/apn-relay/src/setup.ts

@@ -1,34 +0,0 @@
-import { sql } from "drizzle-orm"
-import { db } from "./db"
-
-export async function setup() {
-  await db.execute(sql`
-    CREATE TABLE IF NOT EXISTS device_registration (
-      id varchar(36) NOT NULL,
-      secret_hash varchar(64) NOT NULL,
-      device_token varchar(255) NOT NULL,
-      bundle_id varchar(255) NOT NULL,
-      apns_env varchar(16) NOT NULL DEFAULT 'production',
-      created_at bigint NOT NULL,
-      updated_at bigint NOT NULL,
-      PRIMARY KEY (id),
-      UNIQUE KEY device_registration_secret_token_idx (secret_hash, device_token),
-      KEY device_registration_secret_hash_idx (secret_hash)
-    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-  `)
-
-  await db.execute(sql`
-    CREATE TABLE IF NOT EXISTS delivery_log (
-      id varchar(36) NOT NULL,
-      secret_hash varchar(64) NOT NULL,
-      event_type varchar(32) NOT NULL,
-      session_id varchar(255) NOT NULL,
-      status varchar(16) NOT NULL,
-      error varchar(1024) NULL,
-      created_at bigint NOT NULL,
-      PRIMARY KEY (id),
-      KEY delivery_log_secret_hash_idx (secret_hash),
-      KEY delivery_log_created_at_idx (created_at)
-    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-  `)
-}

packages/apn-relay/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "$schema": "https://json.schemastore.org/tsconfig",
-  "extends": "@tsconfig/bun/tsconfig.json",
-  "compilerOptions": {
-    "lib": ["ESNext", "DOM", "DOM.Iterable"],
-    "noUncheckedIndexedAccess": false
-  }
-}

packages/app/e2e/AGENTS.md

@@ -70,15 +70,7 @@ test("test description", async ({ page, sdk, gotoSession }) => {
 - `openSettings(page)` - Open settings dialog
 - `closeDialog(page, dialog)` - Close any dialog
 - `openSidebar(page)` / `closeSidebar(page)` - Toggle sidebar
-- `waitTerminalReady(page, { term? })` - Wait for a mounted terminal to connect and finish rendering output
-- `runTerminal(page, { cmd, token, term?, timeout? })` - Type into the terminal via the browser and wait for rendered output
 - `withSession(sdk, title, callback)` - Create temp session
-- `withProject(...)` - Create temp project/workspace
-- `sessionIDFromUrl(url)` - Read session ID from URL
-- `slugFromUrl(url)` - Read workspace slug from URL
-- `waitSlug(page, skip?)` - Wait for resolved workspace slug
-- `trackSession(sessionID, directory?)` - Register session for fixture cleanup
-- `trackDirectory(directory)` - Register directory for fixture cleanup
 - `clickListItem(container, filter)` - Click list item by key/text
 
 **Selectors** (`selectors.ts`):
@@ -117,7 +109,7 @@ import { test, expect } from "@playwright/test"
 
 ### Error Handling
 
-Tests should clean up after themselves. Prefer fixture-managed cleanup:
+Tests should clean up after themselves:
 
 ```typescript
 test("test with cleanup", async ({ page, sdk, gotoSession }) => {
@@ -128,11 +120,6 @@ test("test with cleanup", async ({ page, sdk, gotoSession }) => {
 })
 ```
 
-- Prefer `withSession(...)` for temp sessions
-- In `withProject(...)` tests that create sessions or extra workspaces, call `trackSession(sessionID, directory?)` and `trackDirectory(directory)`
-- This lets fixture teardown abort, wait for idle, and clean up safely under CI concurrency
-- Avoid calling `sdk.session.delete(...)` directly
-
 ### Timeouts
 
 Default: 60s per test, 10s per assertion. Override when needed:
@@ -169,51 +156,14 @@ await page.keyboard.press(`${modKey}+B`) // Toggle sidebar
 await page.keyboard.press(`${modKey}+Comma`) // Open settings
 ```
 
-### Terminal Tests
-
-- In terminal tests, type through the browser. Do not write to the PTY through the SDK.
-- Use `waitTerminalReady(page, { term? })` and `runTerminal(page, { cmd, token, term?, timeout? })` from `actions.ts`.
-- These helpers use the fixture-enabled test-only terminal driver and wait for output after the terminal writer settles.
-- After opening the terminal, use `waitTerminalFocusIdle(...)` before the next keyboard action when prompt focus or keyboard routing matters.
-- This avoids racing terminal mount, focus handoff, and prompt readiness when the next step types or sends shortcuts.
-- Avoid `waitForTimeout` and custom DOM or `data-*` readiness checks.
-
-### Wait on state
-
-- Never use wall-clock waits like `page.waitForTimeout(...)` to make a test pass
-- Avoid race-prone flows that assume work is finished after an action
-- Wait or poll on observable state with `expect(...)`, `expect.poll(...)`, or existing helpers
-- Prefer locator assertions like `toBeVisible()`, `toHaveCount(0)`, and `toHaveAttribute(...)` for normal UI state, and reserve `expect.poll(...)` for probe, mock, or backend state
-- Prefer semantic app state over transient DOM visibility when behavior depends on active selection, focus ownership, or async retry loops
-- Do not treat a visible element as proof that the app will route the next action to it
-- When fixing a flake, validate with `--repeat-each` and multiple workers when practical
-
-### Add hooks
-
-- If required state is not observable from the UI, add a small test-only driver or probe in app code instead of sleeps or fragile DOM checks
-- Keep these hooks minimal and purpose-built, following the style of `packages/app/src/testing/terminal.ts`
-- Test-only hooks must be inert unless explicitly enabled; do not add normal-runtime listeners, reactive subscriptions, or per-update allocations for e2e ceremony
-- When mocking routes or APIs, expose explicit mock state and wait on that before asserting post-action UI
-- Add minimal test-only probes for semantic state like the active list item or selected command when DOM intermediates are unstable
-- Prefer probing committed app state over asserting on transient highlight, visibility, or animation states
-
-### Prefer helpers
-
-- Prefer fluent helpers and drivers when they make intent obvious and reduce locator-heavy noise
-- Use direct locators when the interaction is simple and a helper would not add clarity
-- Prefer helpers that both perform an action and verify the app consumed it
-- Avoid composing helpers redundantly when one already includes the other or already waits for the resulting state
-- If a helper already covers the required wait or verification, use it directly instead of layering extra clicks, keypresses, or assertions
-
 ## Writing New Tests
 
 1. Choose appropriate folder or create new one
 2. Import from `../fixtures`
 3. Use helper functions from `../actions` and `../selectors`
-4. When validating routing, use shared helpers from `../actions`. Workspace URL slugs can be canonicalized on Windows, so assert against canonical or resolved workspace slugs.
-5. Clean up any created resources
-6. Use specific selectors (avoid CSS classes)
-7. Test one feature per test file
+4. Clean up any created resources
+5. Use specific selectors (avoid CSS classes)
+6. Test one feature per test file
 
 ## Local Development
 

packages/app/e2e/actions.ts

@@ -1,38 +1,24 @@
-import { base64Decode, base64Encode } from "@opencode-ai/util/encode"
 import { expect, type Locator, type Page } from "@playwright/test"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
 import { execSync } from "node:child_process"
-import { terminalAttr, type E2EWindow } from "../src/testing/terminal"
-import { createSdk, modKey, resolveDirectory, serverUrl } from "./utils"
+import { modKey, serverUrl } from "./utils"
 import {
+  sessionItemSelector,
   dropdownMenuTriggerSelector,
   dropdownMenuContentSelector,
-  projectSwitchSelector,
   projectMenuTriggerSelector,
-  projectCloseMenuSelector,
   projectWorkspacesToggleSelector,
   titlebarRightSelector,
   popoverBodySelector,
   listItemSelector,
   listItemKeySelector,
   listItemKeyStartsWithSelector,
-  promptSelector,
-  terminalSelector,
   workspaceItemSelector,
   workspaceMenuTriggerSelector,
 } from "./selectors"
-
-const phase = new WeakMap<Page, "test" | "cleanup">()
-
-export function setHealthPhase(page: Page, value: "test" | "cleanup") {
-  phase.set(page, value)
-}
-
-export function healthPhase(page: Page) {
-  return phase.get(page) ?? "test"
-}
+import type { createSdk } from "./utils"
 
 export async function defocus(page: Page) {
   await page
@@ -43,141 +29,9 @@ export async function defocus(page: Page) {
     .catch(() => undefined)
 }
 
-async function terminalID(term: Locator) {
-  const id = await term.getAttribute(terminalAttr)
-  if (id) return id
-  throw new Error(`Active terminal missing ${terminalAttr}`)
-}
-
-export async function terminalConnects(page: Page, input?: { term?: Locator }) {
-  const term = input?.term ?? page.locator(terminalSelector).first()
-  const id = await terminalID(term)
-  return page.evaluate((id) => {
-    return (window as E2EWindow).__opencode_e2e?.terminal?.terminals?.[id]?.connects ?? 0
-  }, id)
-}
-
-export async function disconnectTerminal(page: Page, input?: { term?: Locator }) {
-  const term = input?.term ?? page.locator(terminalSelector).first()
-  const id = await terminalID(term)
-  await page.evaluate((id) => {
-    ;(window as E2EWindow).__opencode_e2e?.terminal?.controls?.[id]?.disconnect?.()
-  }, id)
-}
-
-async function terminalReady(page: Page, term?: Locator) {
-  const next = term ?? page.locator(terminalSelector).first()
-  const id = await terminalID(next)
-  return page.evaluate((id) => {
-    const state = (window as E2EWindow).__opencode_e2e?.terminal?.terminals?.[id]
-    return !!state?.connected && (state.settled ?? 0) > 0
-  }, id)
-}
-
-async function terminalFocusIdle(page: Page, term?: Locator) {
-  const next = term ?? page.locator(terminalSelector).first()
-  const id = await terminalID(next)
-  return page.evaluate((id) => {
-    const state = (window as E2EWindow).__opencode_e2e?.terminal?.terminals?.[id]
-    return (state?.focusing ?? 0) === 0
-  }, id)
-}
-
-async function terminalHas(page: Page, input: { term?: Locator; token: string }) {
-  const next = input.term ?? page.locator(terminalSelector).first()
-  const id = await terminalID(next)
-  return page.evaluate(
-    (input) => {
-      const state = (window as E2EWindow).__opencode_e2e?.terminal?.terminals?.[input.id]
-      return state?.rendered.includes(input.token) ?? false
-    },
-    { id, token: input.token },
-  )
-}
-
-async function promptSlashActive(page: Page, id: string) {
-  return page.evaluate((id) => {
-    const state = (window as E2EWindow).__opencode_e2e?.prompt?.current
-    if (state?.popover !== "slash") return false
-    if (!state.slash.ids.includes(id)) return false
-    return state.slash.active === id
-  }, id)
-}
-
-async function promptSlashSelects(page: Page) {
-  return page.evaluate(() => {
-    return (window as E2EWindow).__opencode_e2e?.prompt?.current?.selects ?? 0
-  })
-}
-
-async function promptSlashSelected(page: Page, input: { id: string; count: number }) {
-  return page.evaluate((input) => {
-    const state = (window as E2EWindow).__opencode_e2e?.prompt?.current
-    if (!state) return false
-    return state.selected === input.id && state.selects >= input.count
-  }, input)
-}
-
-export async function waitTerminalReady(page: Page, input?: { term?: Locator; timeout?: number }) {
-  const term = input?.term ?? page.locator(terminalSelector).first()
-  const timeout = input?.timeout ?? 10_000
-  await expect(term).toBeVisible()
-  await expect(term.locator("textarea")).toHaveCount(1)
-  await expect.poll(() => terminalReady(page, term), { timeout }).toBe(true)
-}
-
-export async function waitTerminalFocusIdle(page: Page, input?: { term?: Locator; timeout?: number }) {
-  const term = input?.term ?? page.locator(terminalSelector).first()
-  const timeout = input?.timeout ?? 10_000
-  await waitTerminalReady(page, { term, timeout })
-  await expect.poll(() => terminalFocusIdle(page, term), { timeout }).toBe(true)
-}
-
-export async function showPromptSlash(
-  page: Page,
-  input: { id: string; text: string; prompt?: Locator; timeout?: number },
-) {
-  const prompt = input.prompt ?? page.locator(promptSelector)
-  const timeout = input.timeout ?? 10_000
-  await expect
-    .poll(
-      async () => {
-        await prompt.click().catch(() => false)
-        await prompt.fill(input.text).catch(() => false)
-        return promptSlashActive(page, input.id).catch(() => false)
-      },
-      { timeout },
-    )
-    .toBe(true)
-}
-
-export async function runPromptSlash(
-  page: Page,
-  input: { id: string; text: string; prompt?: Locator; timeout?: number },
-) {
-  const prompt = input.prompt ?? page.locator(promptSelector)
-  const timeout = input.timeout ?? 10_000
-  const count = await promptSlashSelects(page)
-  await showPromptSlash(page, input)
-  await prompt.press("Enter")
-  await expect.poll(() => promptSlashSelected(page, { id: input.id, count: count + 1 }), { timeout }).toBe(true)
-}
-
-export async function runTerminal(page: Page, input: { cmd: string; token: string; term?: Locator; timeout?: number }) {
-  const term = input.term ?? page.locator(terminalSelector).first()
-  const timeout = input.timeout ?? 10_000
-  await waitTerminalReady(page, { term, timeout })
-  const textarea = term.locator("textarea")
-  await term.click()
-  await expect(textarea).toBeFocused()
-  await page.keyboard.type(input.cmd)
-  await page.keyboard.press("Enter")
-  await expect.poll(() => terminalHas(page, { term, token: input.token }), { timeout }).toBe(true)
-}
-
-export async function openPalette(page: Page, key = "K") {
+export async function openPalette(page: Page) {
   await defocus(page)
-  await page.keyboard.press(`${modKey}+${key}`)
+  await page.keyboard.press(`${modKey}+P`)
 
   const dialog = page.getByRole("dialog")
   await expect(dialog).toBeVisible()
@@ -207,49 +61,9 @@ export async function closeDialog(page: Page, dialog: Locator) {
 }
 
 export async function isSidebarClosed(page: Page) {
-  const button = await waitSidebarButton(page, "isSidebarClosed")
-  return (await button.getAttribute("aria-expanded")) !== "true"
-}
-
-async function errorBoundaryText(page: Page) {
-  const title = page.getByRole("heading", { name: /something went wrong/i }).first()
-  if (!(await title.isVisible().catch(() => false))) return
-
-  const description = await page
-    .getByText(/an error occurred while loading the application\./i)
-    .first()
-    .textContent()
-    .catch(() => "")
-  const detail = await page
-    .getByRole("textbox", { name: /error details/i })
-    .first()
-    .inputValue()
-    .catch(async () =>
-      (
-        (await page
-          .getByRole("textbox", { name: /error details/i })
-          .first()
-          .textContent()
-          .catch(() => "")) ?? ""
-      ).trim(),
-    )
-
-  return [title ? "Error boundary" : "", description ?? "", detail ?? ""].filter(Boolean).join("\n")
-}
-
-export async function assertHealthy(page: Page, context: string) {
-  const text = await errorBoundaryText(page)
-  if (!text) return
-  console.log(`[e2e:error-boundary][${context}]\n${text}`)
-  throw new Error(`Error boundary during ${context}\n${text}`)
-}
-
-async function waitSidebarButton(page: Page, context: string) {
-  const button = page.getByRole("button", { name: /toggle sidebar/i }).first()
-  const boundary = page.getByRole("heading", { name: /something went wrong/i }).first()
-  await button.or(boundary).first().waitFor({ state: "visible", timeout: 10_000 })
-  await assertHealthy(page, context)
-  return button
+  const main = page.locator("main")
+  const classes = (await main.getAttribute("class")) ?? ""
+  return classes.includes("xl:border-l")
 }
 
 export async function toggleSidebar(page: Page) {
@@ -260,39 +74,52 @@ export async function toggleSidebar(page: Page) {
 export async function openSidebar(page: Page) {
   if (!(await isSidebarClosed(page))) return
 
-  const button = await waitSidebarButton(page, "openSidebar")
-  await button.click()
+  const button = page.getByRole("button", { name: /toggle sidebar/i }).first()
+  const visible = await button
+    .isVisible()
+    .then((x) => x)
+    .catch(() => false)
 
-  const opened = await expect(button)
-    .toHaveAttribute("aria-expanded", "true", { timeout: 1500 })
+  if (visible) await button.click()
+  if (!visible) await toggleSidebar(page)
+
+  const main = page.locator("main")
+  const opened = await expect(main)
+    .not.toHaveClass(/xl:border-l/, { timeout: 1500 })
     .then(() => true)
     .catch(() => false)
 
   if (opened) return
 
   await toggleSidebar(page)
-  await expect(button).toHaveAttribute("aria-expanded", "true")
+  await expect(main).not.toHaveClass(/xl:border-l/)
 }
 
 export async function closeSidebar(page: Page) {
   if (await isSidebarClosed(page)) return
 
-  const button = await waitSidebarButton(page, "closeSidebar")
-  await button.click()
+  const button = page.getByRole("button", { name: /toggle sidebar/i }).first()
+  const visible = await button
+    .isVisible()
+    .then((x) => x)
+    .catch(() => false)
 
-  const closed = await expect(button)
-    .toHaveAttribute("aria-expanded", "false", { timeout: 1500 })
+  if (visible) await button.click()
+  if (!visible) await toggleSidebar(page)
+
+  const main = page.locator("main")
+  const closed = await expect(main)
+    .toHaveClass(/xl:border-l/, { timeout: 1500 })
     .then(() => true)
     .catch(() => false)
 
   if (closed) return
 
   await toggleSidebar(page)
-  await expect(button).toHaveAttribute("aria-expanded", "false")
+  await expect(main).toHaveClass(/xl:border-l/)
 }
 
 export async function openSettings(page: Page) {
-  await assertHealthy(page, "openSettings")
   await defocus(page)
 
   const dialog = page.getByRole("dialog")
@@ -305,8 +132,6 @@ export async function openSettings(page: Page) {
 
   if (opened) return dialog
 
-  await assertHealthy(page, "openSettings")
-
   await page.getByRole("button", { name: "Settings" }).first().click()
   await expect(dialog).toBeVisible()
   return dialog
@@ -368,157 +193,21 @@ export async function seedProjects(page: Page, input: { directory: string; extra
 
 export async function createTestProject() {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-"))
-  const id = `e2e-${path.basename(root)}`
 
-  await fs.writeFile(path.join(root, "README.md"), `# e2e\n\n${id}\n`)
+  await fs.writeFile(path.join(root, "README.md"), "# e2e\n")
 
   execSync("git init", { cwd: root, stdio: "ignore" })
-  await fs.writeFile(path.join(root, ".git", "opencode"), id)
-  execSync("git config core.fsmonitor false", { cwd: root, stdio: "ignore" })
   execSync("git add -A", { cwd: root, stdio: "ignore" })
   execSync('git -c user.name="e2e" -c user.email="e2e@example.com" commit -m "init" --allow-empty', {
     cwd: root,
     stdio: "ignore",
   })
 
-  return resolveDirectory(root)
+  return root
 }
 
 export async function cleanupTestProject(directory: string) {
-  try {
-    execSync("git fsmonitor--daemon stop", { cwd: directory, stdio: "ignore" })
-  } catch {}
-  await fs.rm(directory, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 }).catch(() => undefined)
-}
-
-export function slugFromUrl(url: string) {
-  return /\/([^/]+)\/session(?:[/?#]|$)/.exec(url)?.[1] ?? ""
-}
-
-async function probeSession(page: Page) {
-  return page
-    .evaluate(() => {
-      const win = window as E2EWindow
-      const current = win.__opencode_e2e?.model?.current
-      if (!current) return null
-      return { dir: current.dir, sessionID: current.sessionID }
-    })
-    .catch(() => null as { dir?: string; sessionID?: string } | null)
-}
-
-export async function waitSlug(page: Page, skip: string[] = []) {
-  let prev = ""
-  let next = ""
-  await expect
-    .poll(
-      async () => {
-        await assertHealthy(page, "waitSlug")
-        const slug = slugFromUrl(page.url())
-        if (!slug) return ""
-        if (skip.includes(slug)) return ""
-        if (slug !== prev) {
-          prev = slug
-          next = ""
-          return ""
-        }
-        next = slug
-        return slug
-      },
-      { timeout: 45_000 },
-    )
-    .not.toBe("")
-  return next
-}
-
-export async function resolveSlug(slug: string) {
-  const directory = base64Decode(slug)
-  if (!directory) throw new Error(`Failed to decode workspace slug: ${slug}`)
-  const resolved = await resolveDirectory(directory)
-  return { directory: resolved, slug: base64Encode(resolved), raw: slug }
-}
-
-export async function waitDir(page: Page, directory: string) {
-  const target = await resolveDirectory(directory)
-  await expect
-    .poll(
-      async () => {
-        await assertHealthy(page, "waitDir")
-        const slug = slugFromUrl(page.url())
-        if (!slug) return ""
-        return resolveSlug(slug)
-          .then((item) => item.directory)
-          .catch(() => "")
-      },
-      { timeout: 45_000 },
-    )
-    .toBe(target)
-  return { directory: target, slug: base64Encode(target) }
-}
-
-export async function waitSession(page: Page, input: { directory: string; sessionID?: string }) {
-  const target = await resolveDirectory(input.directory)
-  await expect
-    .poll(
-      async () => {
-        await assertHealthy(page, "waitSession")
-        const slug = slugFromUrl(page.url())
-        if (!slug) return false
-        const resolved = await resolveSlug(slug).catch(() => undefined)
-        if (!resolved || resolved.directory !== target) return false
-        const current = sessionIDFromUrl(page.url())
-        if (input.sessionID && current !== input.sessionID) return false
-        if (!input.sessionID && current) return false
-
-        const state = await probeSession(page)
-        if (input.sessionID && (!state || state.sessionID !== input.sessionID)) return false
-        if (!input.sessionID && state?.sessionID) return false
-        if (state?.dir) {
-          const dir = await resolveDirectory(state.dir).catch(() => state.dir ?? "")
-          if (dir !== target) return false
-        }
-
-        return page
-          .locator(promptSelector)
-          .first()
-          .isVisible()
-          .catch(() => false)
-      },
-      { timeout: 45_000 },
-    )
-    .toBe(true)
-  return { directory: target, slug: base64Encode(target) }
-}
-
-export async function waitSessionSaved(directory: string, sessionID: string, timeout = 30_000) {
-  const sdk = createSdk(directory)
-  const target = await resolveDirectory(directory)
-
-  await expect
-    .poll(
-      async () => {
-        const data = await sdk.session
-          .get({ sessionID })
-          .then((x) => x.data)
-          .catch(() => undefined)
-        if (!data?.directory) return ""
-        return resolveDirectory(data.directory).catch(() => data.directory)
-      },
-      { timeout },
-    )
-    .toBe(target)
-
-  await expect
-    .poll(
-      async () => {
-        const items = await sdk.session
-          .messages({ sessionID, limit: 20 })
-          .then((x) => x.data ?? [])
-          .catch(() => [])
-        return items.some((item) => item.info.role === "user")
-      },
-      { timeout },
-    )
-    .toBe(true)
+  await fs.rm(directory, { recursive: true, force: true }).catch(() => undefined)
 }
 
 export function sessionIDFromUrl(url: string) {
@@ -527,7 +216,7 @@ export function sessionIDFromUrl(url: string) {
 }
 
 export async function hoverSessionItem(page: Page, sessionID: string) {
-  const sessionEl = page.locator(`[data-session-id="${sessionID}"]`).last()
+  const sessionEl = page.locator(sessionItemSelector(sessionID)).first()
   await expect(sessionEl).toBeVisible()
   await sessionEl.hover()
   return sessionEl
@@ -628,57 +317,6 @@ export async function clickListItem(
   return item
 }
 
-async function status(sdk: ReturnType<typeof createSdk>, sessionID: string) {
-  const data = await sdk.session
-    .status()
-    .then((x) => x.data ?? {})
-    .catch(() => undefined)
-  return data?.[sessionID]
-}
-
-async function stable(sdk: ReturnType<typeof createSdk>, sessionID: string, timeout = 10_000) {
-  let prev = ""
-  await expect
-    .poll(
-      async () => {
-        const info = await sdk.session
-          .get({ sessionID })
-          .then((x) => x.data)
-          .catch(() => undefined)
-        if (!info) return true
-        const next = `${info.title}:${info.time.updated ?? info.time.created}`
-        if (next !== prev) {
-          prev = next
-          return false
-        }
-        return true
-      },
-      { timeout },
-    )
-    .toBe(true)
-}
-
-export async function waitSessionIdle(sdk: ReturnType<typeof createSdk>, sessionID: string, timeout = 30_000) {
-  await expect.poll(() => status(sdk, sessionID).then((x) => !x || x.type === "idle"), { timeout }).toBe(true)
-}
-
-export async function cleanupSession(input: {
-  sessionID: string
-  directory?: string
-  sdk?: ReturnType<typeof createSdk>
-}) {
-  const sdk = input.sdk ?? (input.directory ? createSdk(input.directory) : undefined)
-  if (!sdk) throw new Error("cleanupSession requires sdk or directory")
-  await waitSessionIdle(sdk, input.sessionID, 5_000).catch(() => undefined)
-  const current = await status(sdk, input.sessionID).catch(() => undefined)
-  if (current && current.type !== "idle") {
-    await sdk.session.abort({ sessionID: input.sessionID }).catch(() => undefined)
-    await waitSessionIdle(sdk, input.sessionID).catch(() => undefined)
-  }
-  await stable(sdk, input.sessionID).catch(() => undefined)
-  await sdk.session.delete({ sessionID: input.sessionID }).catch(() => undefined)
-}
-
 export async function withSession<T>(
   sdk: ReturnType<typeof createSdk>,
   title: string,
@@ -690,7 +328,7 @@ export async function withSession<T>(
   try {
     return await callback(session)
   } finally {
-    await cleanupSession({ sdk, sessionID: session.id })
+    await sdk.session.delete({ sessionID: session.id }).catch(() => undefined)
   }
 }
 
@@ -803,64 +441,6 @@ export async function seedSessionPermission(
   return { id: result.id }
 }
 
-export async function seedSessionTask(
-  sdk: ReturnType<typeof createSdk>,
-  input: {
-    sessionID: string
-    description: string
-    prompt: string
-    subagentType?: string
-  },
-) {
-  const text = [
-    "Your only valid response is one task tool call.",
-    `Use this JSON input: ${JSON.stringify({
-      description: input.description,
-      prompt: input.prompt,
-      subagent_type: input.subagentType ?? "general",
-    })}`,
-    "Do not output plain text.",
-    "Wait for the task to start and return the child session id.",
-  ].join("\n")
-
-  const result = await seed({
-    sdk,
-    sessionID: input.sessionID,
-    prompt: text,
-    timeout: 90_000,
-    probe: async () => {
-      const messages = await sdk.session.messages({ sessionID: input.sessionID, limit: 50 }).then((x) => x.data ?? [])
-      const part = messages
-        .flatMap((message) => message.parts)
-        .find((part) => {
-          if (part.type !== "tool" || part.tool !== "task") return false
-          if (!("state" in part) || !part.state || typeof part.state !== "object") return false
-          if (!("input" in part.state) || !part.state.input || typeof part.state.input !== "object") return false
-          if (!("description" in part.state.input) || part.state.input.description !== input.description) return false
-          if (!("metadata" in part.state) || !part.state.metadata || typeof part.state.metadata !== "object")
-            return false
-          if (!("sessionId" in part.state.metadata)) return false
-          return typeof part.state.metadata.sessionId === "string" && part.state.metadata.sessionId.length > 0
-        })
-
-      if (!part || !("state" in part) || !part.state || typeof part.state !== "object") return
-      if (!("metadata" in part.state) || !part.state.metadata || typeof part.state.metadata !== "object") return
-      if (!("sessionId" in part.state.metadata)) return
-      const id = part.state.metadata.sessionId
-      if (typeof id !== "string" || !id) return
-      const child = await sdk.session
-        .get({ sessionID: id })
-        .then((x) => x.data)
-        .catch(() => undefined)
-      if (!child?.id) return
-      return { sessionID: id }
-    },
-  })
-
-  if (!result) throw new Error("Timed out seeding task tool")
-  return result
-}
-
 export async function seedSessionTodos(
   sdk: ReturnType<typeof createSdk>,
   input: {
@@ -932,51 +512,35 @@ export async function openStatusPopover(page: Page) {
 }
 
 export async function openProjectMenu(page: Page, projectSlug: string) {
-  await openSidebar(page)
-  const item = page.locator(projectSwitchSelector(projectSlug)).first()
-  await expect(item).toBeVisible()
-  await item.hover()
-
   const trigger = page.locator(projectMenuTriggerSelector(projectSlug)).first()
   await expect(trigger).toHaveCount(1)
-  await expect(trigger).toBeVisible()
-
-  const menu = page
-    .locator(dropdownMenuContentSelector)
-    .filter({ has: page.locator(projectCloseMenuSelector(projectSlug)) })
-    .first()
-  const close = menu.locator(projectCloseMenuSelector(projectSlug)).first()
-
-  const clicked = await trigger
-    .click({ force: true, timeout: 1500 })
-    .then(() => true)
-    .catch(() => false)
-
-  if (clicked) {
-    const opened = await menu
-      .waitFor({ state: "visible", timeout: 1500 })
-      .then(() => true)
-      .catch(() => false)
-    if (opened) {
-      await expect(close).toBeVisible()
-      return menu
-    }
-  }
 
   await trigger.focus()
   await page.keyboard.press("Enter")
 
+  const menu = page.locator(dropdownMenuContentSelector).first()
   const opened = await menu
     .waitFor({ state: "visible", timeout: 1500 })
     .then(() => true)
     .catch(() => false)
 
   if (opened) {
-    await expect(close).toBeVisible()
+    const viewport = page.viewportSize()
+    const x = viewport ? Math.max(viewport.width - 5, 0) : 1200
+    const y = viewport ? Math.max(viewport.height - 5, 0) : 800
+    await page.mouse.move(x, y)
     return menu
   }
 
-  throw new Error(`Failed to open project menu: ${projectSlug}`)
+  await trigger.click({ force: true })
+
+  await expect(menu).toBeVisible()
+
+  const viewport = page.viewportSize()
+  const x = viewport ? Math.max(viewport.width - 5, 0) : 1200
+  const y = viewport ? Math.max(viewport.height - 5, 0) : 800
+  await page.mouse.move(x, y)
+  return menu
 }
 
 export async function setWorkspacesEnabled(page: Page, projectSlug: string, enabled: boolean) {
@@ -989,18 +553,11 @@ export async function setWorkspacesEnabled(page: Page, projectSlug: string, enab
 
   if (current === enabled) return
 
-  const flip = async (timeout?: number) => {
-    const menu = await openProjectMenu(page, projectSlug)
-    const toggle = menu.locator(projectWorkspacesToggleSelector(projectSlug)).first()
-    await expect(toggle).toBeVisible()
-    return toggle.click({ force: true, timeout })
-  }
+  await openProjectMenu(page, projectSlug)
 
-  const flipped = await flip(1500)
-    .then(() => true)
-    .catch(() => false)
-
-  if (!flipped) await flip()
+  const toggle = page.locator(projectWorkspacesToggleSelector(projectSlug)).first()
+  await expect(toggle).toBeVisible()
+  await toggle.click({ force: true })
 
   const expected = enabled ? "New workspace" : "New session"
   await expect(page.getByRole("button", { name: expected }).first()).toBeVisible()

packages/app/e2e/app/home.spec.ts

@@ -1,20 +1,17 @@
 import { test, expect } from "../fixtures"
-import { serverNamePattern } from "../utils"
+import { serverName } from "../utils"
 
 test("home renders and shows core entrypoints", async ({ page }) => {
   await page.goto("/")
-  const nav = page.locator('[data-component="sidebar-nav-desktop"]')
 
   await expect(page.getByRole("button", { name: "Open project" }).first()).toBeVisible()
-  await expect(nav.getByText("No projects open")).toBeVisible()
-  await expect(nav.getByText("Open a project to get started")).toBeVisible()
-  await expect(page.getByRole("button", { name: serverNamePattern })).toBeVisible()
+  await expect(page.getByRole("button", { name: serverName })).toBeVisible()
 })
 
 test("server picker dialog opens from home", async ({ page }) => {
   await page.goto("/")
 
-  const trigger = page.getByRole("button", { name: serverNamePattern })
+  const trigger = page.getByRole("button", { name: serverName })
   await expect(trigger).toBeVisible()
   await trigger.click()
 

packages/app/e2e/app/palette.spec.ts

@@ -1,5 +1,5 @@
 import { test, expect } from "../fixtures"
-import { closeDialog, openPalette } from "../actions"
+import { openPalette } from "../actions"
 
 test("search palette opens and closes", async ({ page, gotoSession }) => {
   await gotoSession()
@@ -9,12 +9,3 @@ test("search palette opens and closes", async ({ page, gotoSession }) => {
   await page.keyboard.press("Escape")
   await expect(dialog).toHaveCount(0)
 })
-
-test("search palette also opens with cmd+p", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const dialog = await openPalette(page, "P")
-
-  await closeDialog(page, dialog)
-  await expect(dialog).toHaveCount(0)
-})

packages/app/e2e/app/server-default.spec.ts

@@ -1,6 +1,6 @@
 import { test, expect } from "../fixtures"
-import { serverNamePattern, serverUrls } from "../utils"
-import { closeDialog, clickMenuItem } from "../actions"
+import { serverName, serverUrl } from "../utils"
+import { clickListItem, closeDialog, clickMenuItem } from "../actions"
 
 const DEFAULT_SERVER_URL_KEY = "opencode.settings.dat:defaultServerUrl"
 
@@ -31,9 +31,10 @@ test("can set a default server on web", async ({ page, gotoSession }) => {
   const dialog = page.getByRole("dialog")
   await expect(dialog).toBeVisible()
 
-  await expect(dialog.getByText(serverNamePattern).first()).toBeVisible()
+  const row = dialog.locator('[data-slot="list-item"]').filter({ hasText: serverName }).first()
+  await expect(row).toBeVisible()
 
-  const menuTrigger = dialog.locator('[data-slot="dropdown-menu-trigger"]').first()
+  const menuTrigger = row.locator('[data-slot="dropdown-menu-trigger"]').first()
   await expect(menuTrigger).toBeVisible()
   await menuTrigger.click({ force: true })
 
@@ -41,18 +42,14 @@ test("can set a default server on web", async ({ page, gotoSession }) => {
   await expect(menu).toBeVisible()
   await clickMenuItem(menu, /set as default/i)
 
-  await expect
-    .poll(async () =>
-      serverUrls.includes((await page.evaluate((key) => localStorage.getItem(key), DEFAULT_SERVER_URL_KEY)) ?? ""),
-    )
-    .toBe(true)
-  await expect(dialog.getByText("Default", { exact: true })).toBeVisible()
+  await expect.poll(() => page.evaluate((key) => localStorage.getItem(key), DEFAULT_SERVER_URL_KEY)).toBe(serverUrl)
+  await expect(row.getByText("Default", { exact: true })).toBeVisible()
 
   await closeDialog(page, dialog)
 
   await ensurePopoverOpen()
 
-  const serverRow = popover.locator("button").filter({ hasText: serverNamePattern }).first()
+  const serverRow = popover.locator("button").filter({ hasText: serverName }).first()
   await expect(serverRow).toBeVisible()
   await expect(serverRow.getByText("Default", { exact: true })).toBeVisible()
 })

packages/app/e2e/app/titlebar-history.spec.ts

@@ -16,6 +16,7 @@ test("titlebar back/forward navigates between sessions", async ({ page, slug, sd
 
       const link = page.locator(`[data-session-id="${two.id}"] a`).first()
       await expect(link).toBeVisible()
+      await link.scrollIntoViewIfNeeded()
       await link.click()
 
       await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))
@@ -55,6 +56,7 @@ test("titlebar forward is cleared after branching history from sidebar", async (
 
         const second = page.locator(`[data-session-id="${b.id}"] a`).first()
         await expect(second).toBeVisible()
+        await second.scrollIntoViewIfNeeded()
         await second.click()
 
         await expect(page).toHaveURL(new RegExp(`/${slug}/session/${b.id}(?:\\?|#|$)`))
@@ -74,6 +76,7 @@ test("titlebar forward is cleared after branching history from sidebar", async (
 
         const third = page.locator(`[data-session-id="${c.id}"] a`).first()
         await expect(third).toBeVisible()
+        await third.scrollIntoViewIfNeeded()
         await third.click()
 
         await expect(page).toHaveURL(new RegExp(`/${slug}/session/${c.id}(?:\\?|#|$)`))
@@ -99,6 +102,7 @@ test("keyboard shortcuts navigate titlebar history", async ({ page, slug, sdk, g
 
       const link = page.locator(`[data-session-id="${two.id}"] a`).first()
       await expect(link).toBeVisible()
+      await link.scrollIntoViewIfNeeded()
       await link.click()
 
       await expect(page).toHaveURL(new RegExp(`/${slug}/session/${two.id}(?:\\?|#|$)`))

packages/app/e2e/commands/panels.spec.ts

@@ -10,8 +10,6 @@ const expanded = async (el: { getAttribute: (name: string) => Promise<string | n
 test("review panel can be toggled via keybind", async ({ page, gotoSession }) => {
   await gotoSession()
 
-  const reviewPanel = page.locator("#review-panel")
-
   const treeToggle = page.getByRole("button", { name: "Toggle file tree" }).first()
   await expect(treeToggle).toBeVisible()
   if (await expanded(treeToggle)) await treeToggle.click()
@@ -21,13 +19,13 @@ test("review panel can be toggled via keybind", async ({ page, gotoSession }) =>
   await expect(reviewToggle).toBeVisible()
   if (await expanded(reviewToggle)) await reviewToggle.click()
   await expect(reviewToggle).toHaveAttribute("aria-expanded", "false")
-  await expect(reviewPanel).toHaveAttribute("aria-hidden", "true")
+  await expect(page.locator("#review-panel")).toHaveCount(0)
 
   await page.keyboard.press(`${modKey}+Shift+R`)
   await expect(reviewToggle).toHaveAttribute("aria-expanded", "true")
-  await expect(reviewPanel).toHaveAttribute("aria-hidden", "false")
+  await expect(page.locator("#review-panel")).toBeVisible()
 
   await page.keyboard.press(`${modKey}+Shift+R`)
   await expect(reviewToggle).toHaveAttribute("aria-expanded", "false")
-  await expect(reviewPanel).toHaveAttribute("aria-hidden", "true")
+  await expect(page.locator("#review-panel")).toHaveCount(0)
 })

packages/app/e2e/files/file-tree.spec.ts

@@ -43,13 +43,6 @@ test("file tree can expand folders and open a file", async ({ page, gotoSession
   await tab.click()
   await expect(tab).toHaveAttribute("aria-selected", "true")
 
-  await toggle.click()
-  await expect(toggle).toHaveAttribute("aria-expanded", "false")
-
-  await toggle.click()
-  await expect(toggle).toHaveAttribute("aria-expanded", "true")
-  await expect(allTab).toHaveAttribute("aria-selected", "true")
-
   const viewer = page.locator('[data-component="file"][data-mode="text"]').first()
   await expect(viewer).toBeVisible()
   await expect(viewer).toContainText("export default function FileTree")

packages/app/e2e/files/file-viewer.spec.ts

@@ -101,56 +101,3 @@ test("cmd+f opens text viewer search while prompt is focused", async ({ page, go
   await expect(findInput).toBeVisible()
   await expect(findInput).toBeFocused()
 })
-
-test("cmd+f opens text viewer search while prompt is not focused", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  await page.locator(promptSelector).click()
-  await page.keyboard.type("/open")
-
-  const command = page.locator('[data-slash-id="file.open"]').first()
-  await expect(command).toBeVisible()
-  await page.keyboard.press("Enter")
-
-  const dialog = page
-    .getByRole("dialog")
-    .filter({ has: page.getByPlaceholder(/search files/i) })
-    .first()
-  await expect(dialog).toBeVisible()
-
-  const input = dialog.getByRole("textbox").first()
-  await input.fill("package.json")
-
-  const items = dialog.locator('[data-slot="list-item"][data-key^="file:"]')
-  let index = -1
-  await expect
-    .poll(
-      async () => {
-        const keys = await items.evaluateAll((nodes) => nodes.map((node) => node.getAttribute("data-key") ?? ""))
-        index = keys.findIndex((key) => /packages[\\/]+app[\\/]+package\.json$/i.test(key.replace(/^file:/, "")))
-        return index >= 0
-      },
-      { timeout: 30_000 },
-    )
-    .toBe(true)
-
-  const item = items.nth(index)
-  await expect(item).toBeVisible()
-  await item.click()
-
-  await expect(dialog).toHaveCount(0)
-
-  const tab = page.getByRole("tab", { name: "package.json" })
-  await expect(tab).toBeVisible()
-  await tab.click()
-
-  const viewer = page.locator('[data-component="file"][data-mode="text"]').first()
-  await expect(viewer).toBeVisible()
-
-  await viewer.click()
-  await page.keyboard.press(`${modKey}+f`)
-
-  const findInput = page.getByPlaceholder("Find")
-  await expect(findInput).toBeVisible()
-  await expect(findInput).toBeFocused()
-})

packages/app/e2e/fixtures.ts

@@ -1,16 +1,6 @@
 import { test as base, expect, type Page } from "@playwright/test"
-import type { E2EWindow } from "../src/testing/terminal"
-import {
-  healthPhase,
-  cleanupSession,
-  cleanupTestProject,
-  createTestProject,
-  setHealthPhase,
-  seedProjects,
-  sessionIDFromUrl,
-  waitSlug,
-  waitSession,
-} from "./actions"
+import { cleanupTestProject, createTestProject, seedProjects } from "./actions"
+import { promptSelector } from "./selectors"
 import { createSdk, dirSlug, getWorktree, sessionPath } from "./utils"
 
 export const settingsKey = "settings.v3"
@@ -23,8 +13,6 @@ type TestFixtures = {
       directory: string
       slug: string
       gotoSession: (sessionID?: string) => Promise<void>
-      trackSession: (sessionID: string, directory?: string) => void
-      trackDirectory: (directory: string) => void
     }) => Promise<T>,
     options?: { extra?: string[] },
   ) => Promise<T>
@@ -36,29 +24,6 @@ type WorkerFixtures = {
 }
 
 export const test = base.extend<TestFixtures, WorkerFixtures>({
-  page: async ({ page }, use) => {
-    let boundary: string | undefined
-    setHealthPhase(page, "test")
-    const consoleHandler = (msg: { text(): string }) => {
-      const text = msg.text()
-      if (!text.includes("[e2e:error-boundary]")) return
-      if (healthPhase(page) === "cleanup") {
-        console.warn(`[e2e:error-boundary][cleanup-warning]\n${text}`)
-        return
-      }
-      boundary ||= text
-      console.log(text)
-    }
-    const pageErrorHandler = (err: Error) => {
-      console.log(`[e2e:pageerror] ${err.stack || err.message}`)
-    }
-    page.on("console", consoleHandler)
-    page.on("pageerror", pageErrorHandler)
-    await use(page)
-    page.off("console", consoleHandler)
-    page.off("pageerror", pageErrorHandler)
-    if (boundary) throw new Error(boundary)
-  },
   directory: [
     async ({}, use) => {
       const directory = await getWorktree()
@@ -80,44 +45,26 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
 
     const gotoSession = async (sessionID?: string) => {
       await page.goto(sessionPath(directory, sessionID))
-      await waitSession(page, { directory, sessionID })
+      await expect(page.locator(promptSelector)).toBeVisible()
     }
     await use(gotoSession)
   },
   withProject: async ({ page }, use) => {
     await use(async (callback, options) => {
-      const root = await createTestProject()
-      const sessions = new Map<string, string>()
-      const dirs = new Set<string>()
-      await seedStorage(page, { directory: root, extra: options?.extra })
+      const directory = await createTestProject()
+      const slug = dirSlug(directory)
+      await seedStorage(page, { directory, extra: options?.extra })
 
       const gotoSession = async (sessionID?: string) => {
-        await page.goto(sessionPath(root, sessionID))
-        await waitSession(page, { directory: root, sessionID })
-        const current = sessionIDFromUrl(page.url())
-        if (current) trackSession(current)
-      }
-
-      const trackSession = (sessionID: string, directory?: string) => {
-        sessions.set(sessionID, directory ?? root)
-      }
-
-      const trackDirectory = (directory: string) => {
-        if (directory !== root) dirs.add(directory)
+        await page.goto(sessionPath(directory, sessionID))
+        await expect(page.locator(promptSelector)).toBeVisible()
       }
 
       try {
         await gotoSession()
-        const slug = await waitSlug(page)
-        return await callback({ directory: root, slug, gotoSession, trackSession, trackDirectory })
+        return await callback({ directory, slug, gotoSession })
       } finally {
-        setHealthPhase(page, "cleanup")
-        await Promise.allSettled(
-          Array.from(sessions, ([sessionID, directory]) => cleanupSession({ sessionID, directory })),
-        )
-        await Promise.allSettled(Array.from(dirs, (directory) => cleanupTestProject(directory)))
-        await cleanupTestProject(root)
-        setHealthPhase(page, "test")
+        await cleanupTestProject(directory)
       }
     })
   },
@@ -126,20 +73,6 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
 async function seedStorage(page: Page, input: { directory: string; extra?: string[] }) {
   await seedProjects(page, input)
   await page.addInitScript(() => {
-    const win = window as E2EWindow
-    win.__opencode_e2e = {
-      ...win.__opencode_e2e,
-      model: {
-        enabled: true,
-      },
-      prompt: {
-        enabled: true,
-      },
-      terminal: {
-        enabled: true,
-        terminals: {},
-      },
-    }
     localStorage.setItem(
       "opencode.global.dat:model",
       JSON.stringify({

packages/app/e2e/projects/project-edit.spec.ts

@@ -1,15 +1,25 @@
 import { test, expect } from "../fixtures"
-import { clickMenuItem, openProjectMenu, openSidebar } from "../actions"
+import { openSidebar } from "../actions"
 
 test("dialog edit project updates name and startup script", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
-  await withProject(async ({ slug }) => {
+  await withProject(async () => {
     await openSidebar(page)
 
     const open = async () => {
-      const menu = await openProjectMenu(page, slug)
-      await clickMenuItem(menu, /^Edit$/i, { force: true })
+      const header = page.locator(".group\\/project").first()
+      await header.hover()
+      const trigger = header.getByRole("button", { name: "More options" }).first()
+      await expect(trigger).toBeVisible()
+      await trigger.click({ force: true })
+
+      const menu = page.locator('[data-component="dropdown-menu-content"]').first()
+      await expect(menu).toBeVisible()
+
+      const editItem = menu.getByRole("menuitem", { name: "Edit" }).first()
+      await expect(editItem).toBeVisible()
+      await editItem.click({ force: true })
 
       const dialog = page.getByRole("dialog")
       await expect(dialog).toBeVisible()

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

@@ -1,8 +1,36 @@
 import { test, expect } from "../fixtures"
 import { createTestProject, cleanupTestProject, openSidebar, clickMenuItem, openProjectMenu } from "../actions"
-import { projectSwitchSelector } from "../selectors"
+import { projectCloseHoverSelector, projectSwitchSelector } from "../selectors"
 import { dirSlug } from "../utils"
 
+test("can close a project via hover card close button", async ({ page, withProject }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const other = await createTestProject()
+  const otherSlug = dirSlug(other)
+
+  try {
+    await withProject(
+      async () => {
+        await openSidebar(page)
+
+        const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+        await expect(otherButton).toBeVisible()
+        await otherButton.hover()
+
+        const close = page.locator(projectCloseHoverSelector(otherSlug)).first()
+        await expect(close).toBeVisible()
+        await close.click()
+
+        await expect(otherButton).toHaveCount(0)
+      },
+      { extra: [other] },
+    )
+  } finally {
+    await cleanupTestProject(other)
+  }
+})
+
 test("closing active project navigates to another open project", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
@@ -25,26 +53,16 @@ test("closing active project navigates to another open project", async ({ page,
         await clickMenuItem(menu, /^Close$/i, { force: true })
 
         await expect
-          .poll(
-            () => {
-              const pathname = new URL(page.url()).pathname
-              if (new RegExp(`^/${slug}/session(?:/[^/]+)?/?$`).test(pathname)) return "project"
-              if (pathname === "/") return "home"
-              return ""
-            },
-            { timeout: 15_000 },
-          )
+          .poll(() => {
+            const pathname = new URL(page.url()).pathname
+            if (new RegExp(`^/${slug}/session(?:/[^/]+)?/?$`).test(pathname)) return "project"
+            if (pathname === "/") return "home"
+            return ""
+          })
           .toMatch(/^(project|home)$/)
 
         await expect(page).not.toHaveURL(new RegExp(`/${otherSlug}/session(?:[/?#]|$)`))
-        await expect
-          .poll(
-            async () => {
-              return await page.locator(projectSwitchSelector(otherSlug)).count()
-            },
-            { timeout: 15_000 },
-          )
-          .toBe(0)
+        await expect(otherButton).toHaveCount(0)
       },
       { extra: [other] },
     )

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

@@ -5,14 +5,15 @@ import {
   createTestProject,
   cleanupTestProject,
   openSidebar,
-  sessionIDFromUrl,
   setWorkspacesEnabled,
-  waitSession,
-  waitSessionSaved,
-  waitSlug,
+  sessionIDFromUrl,
 } from "../actions"
 import { projectSwitchSelector, promptSelector, workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
-import { dirSlug, resolveDirectory } from "../utils"
+import { createSdk, dirSlug, sessionPath } from "../utils"
+
+function slugFromUrl(url: string) {
+  return /\/([^/]+)\/session(?:\/|$)/.exec(url)?.[1] ?? ""
+}
 
 test("can switch between projects from sidebar", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
@@ -50,33 +51,46 @@ test("switching back to a project opens the latest workspace session", async ({
 
   const other = await createTestProject()
   const otherSlug = dirSlug(other)
+  let rootDir: string | undefined
+  let workspaceDir: string | undefined
+  let sessionID: string | undefined
+
   try {
     await withProject(
-      async ({ directory, slug, trackSession, trackDirectory }) => {
+      async ({ directory, slug }) => {
+        rootDir = directory
         await defocus(page)
-        await setWorkspacesEnabled(page, slug, true)
         await openSidebar(page)
-        await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
+        await setWorkspacesEnabled(page, slug, true)
 
         await page.getByRole("button", { name: "New workspace" }).first().click()
 
-        const raw = await waitSlug(page, [slug])
-        const dir = base64Decode(raw)
-        if (!dir) throw new Error(`Failed to decode workspace slug: ${raw}`)
-        const space = await resolveDirectory(dir)
-        const next = dirSlug(space)
-        trackDirectory(space)
+        await expect
+          .poll(
+            () => {
+              const next = slugFromUrl(page.url())
+              if (!next) return ""
+              if (next === slug) return ""
+              return next
+            },
+            { timeout: 45_000 },
+          )
+          .not.toBe("")
+
+        const workspaceSlug = slugFromUrl(page.url())
+        workspaceDir = base64Decode(workspaceSlug)
+        if (!workspaceDir) throw new Error(`Failed to decode workspace slug: ${workspaceSlug}`)
         await openSidebar(page)
 
-        const item = page.locator(`${workspaceItemSelector(next)}, ${workspaceItemSelector(raw)}`).first()
-        await expect(item).toBeVisible()
-        await item.hover()
+        const workspace = page.locator(workspaceItemSelector(workspaceSlug)).first()
+        await expect(workspace).toBeVisible()
+        await workspace.hover()
 
-        const btn = page.locator(`${workspaceNewSessionSelector(next)}, ${workspaceNewSessionSelector(raw)}`).first()
-        await expect(btn).toBeVisible()
-        await btn.click({ force: true })
+        const newSession = page.locator(workspaceNewSessionSelector(workspaceSlug)).first()
+        await expect(newSession).toBeVisible()
+        await newSession.click({ force: true })
 
-        await waitSession(page, { directory: space })
+        await expect(page).toHaveURL(new RegExp(`/${workspaceSlug}/session(?:[/?#]|$)`))
 
         // Create a session by sending a prompt
         const prompt = page.locator(promptSelector)
@@ -89,28 +103,41 @@ test("switching back to a project opens the latest workspace session", async ({
 
         const created = sessionIDFromUrl(page.url())
         if (!created) throw new Error(`Failed to get session ID from url: ${page.url()}`)
-        trackSession(created, space)
-        await waitSessionSaved(space, created)
+        sessionID = created
 
-        await expect(page).toHaveURL(new RegExp(`/${next}/session/${created}(?:[/?#]|$)`))
+        await expect(page).toHaveURL(new RegExp(`/${workspaceSlug}/session/${created}(?:[/?#]|$)`))
 
         await openSidebar(page)
 
         const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
         await expect(otherButton).toBeVisible()
-        await otherButton.click({ force: true })
-        await waitSession(page, { directory: other })
+        await otherButton.click()
+        await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
 
         const rootButton = page.locator(projectSwitchSelector(slug)).first()
         await expect(rootButton).toBeVisible()
-        await rootButton.click({ force: true })
+        await rootButton.click()
 
-        await waitSession(page, { directory: space, sessionID: created })
+        await expect.poll(() => sessionIDFromUrl(page.url()) ?? "").toBe(created)
         await expect(page).toHaveURL(new RegExp(`/session/${created}(?:[/?#]|$)`))
       },
       { extra: [other] },
     )
   } finally {
+    if (sessionID) {
+      const id = sessionID
+      const dirs = [rootDir, workspaceDir].filter((x): x is string => !!x)
+      await Promise.all(
+        dirs.map((directory) =>
+          createSdk(directory)
+            .session.delete({ sessionID: id })
+            .catch(() => undefined),
+        ),
+      )
+    }
+    if (workspaceDir) {
+      await cleanupTestProject(workspaceDir)
+    }
     await cleanupTestProject(other)
   }
 })

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

@@ -1,94 +1,144 @@
+import { base64Decode } from "@opencode-ai/util/encode"
 import type { Page } from "@playwright/test"
 import { test, expect } from "../fixtures"
-import {
-  openSidebar,
-  resolveSlug,
-  sessionIDFromUrl,
-  setWorkspacesEnabled,
-  waitDir,
-  waitSession,
-  waitSessionSaved,
-  waitSlug,
-} from "../actions"
+import { cleanupTestProject, openSidebar, sessionIDFromUrl, setWorkspacesEnabled } from "../actions"
 import { promptSelector, workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
 import { createSdk } from "../utils"
 
-function item(space: { slug: string; raw: string }) {
-  return `${workspaceItemSelector(space.slug)}, ${workspaceItemSelector(space.raw)}`
+function slugFromUrl(url: string) {
+  return /\/([^/]+)\/session(?:\/|$)/.exec(url)?.[1] ?? ""
 }
 
-function button(space: { slug: string; raw: string }) {
-  return `${workspaceNewSessionSelector(space.slug)}, ${workspaceNewSessionSelector(space.raw)}`
-}
-
-async function waitWorkspaceReady(page: Page, space: { slug: string; raw: string }) {
+async function waitWorkspaceReady(page: Page, slug: string) {
   await openSidebar(page)
-  await expect(page.locator(item(space)).first()).toBeVisible({ timeout: 60_000 })
+  await expect
+    .poll(
+      async () => {
+        const item = page.locator(workspaceItemSelector(slug)).first()
+        try {
+          await item.hover({ timeout: 500 })
+          return true
+        } catch {
+          return false
+        }
+      },
+      { timeout: 60_000 },
+    )
+    .toBe(true)
 }
 
 async function createWorkspace(page: Page, root: string, seen: string[]) {
   await openSidebar(page)
   await page.getByRole("button", { name: "New workspace" }).first().click()
 
-  const next = await resolveSlug(await waitSlug(page, [root, ...seen]))
-  await waitDir(page, next.directory)
-  return next
+  await expect
+    .poll(
+      () => {
+        const slug = slugFromUrl(page.url())
+        if (!slug) return ""
+        if (slug === root) return ""
+        if (seen.includes(slug)) return ""
+        return slug
+      },
+      { timeout: 45_000 },
+    )
+    .not.toBe("")
+
+  const slug = slugFromUrl(page.url())
+  const directory = base64Decode(slug)
+  if (!directory) throw new Error(`Failed to decode workspace slug: ${slug}`)
+  return { slug, directory }
 }
 
-async function openWorkspaceNewSession(page: Page, space: { slug: string; raw: string; directory: string }) {
-  await waitWorkspaceReady(page, space)
+async function openWorkspaceNewSession(page: Page, slug: string) {
+  await waitWorkspaceReady(page, slug)
 
-  const row = page.locator(item(space)).first()
-  await row.hover()
+  const item = page.locator(workspaceItemSelector(slug)).first()
+  await item.hover()
 
-  const next = page.locator(button(space)).first()
-  await expect(next).toBeVisible()
-  await next.click({ force: true })
+  const button = page.locator(workspaceNewSessionSelector(slug)).first()
+  await expect(button).toBeVisible()
+  await button.click({ force: true })
 
-  await waitSession(page, { directory: space.directory })
-  await expect.poll(() => sessionIDFromUrl(page.url()) ?? "").toBe("")
+  await expect.poll(() => slugFromUrl(page.url())).toBe(slug)
+  await expect(page).toHaveURL(new RegExp(`/${slug}/session(?:[/?#]|$)`))
 }
 
-async function createSessionFromWorkspace(
-  page: Page,
-  space: { slug: string; raw: string; directory: string },
-  text: string,
-) {
-  await openWorkspaceNewSession(page, space)
+async function createSessionFromWorkspace(page: Page, slug: string, text: string) {
+  await openWorkspaceNewSession(page, slug)
 
   const prompt = page.locator(promptSelector)
   await expect(prompt).toBeVisible()
+  await expect(prompt).toBeEditable()
+  await prompt.click()
+  await expect(prompt).toBeFocused()
   await prompt.fill(text)
-  await page.keyboard.press("Enter")
+  await expect.poll(async () => ((await prompt.textContent()) ?? "").trim()).toContain(text)
+  await prompt.press("Enter")
+
+  await expect.poll(() => slugFromUrl(page.url())).toBe(slug)
+  await expect.poll(() => sessionIDFromUrl(page.url()) ?? "", { timeout: 30_000 }).not.toBe("")
 
-  await expect.poll(() => sessionIDFromUrl(page.url()) ?? "", { timeout: 15_000 }).not.toBe("")
   const sessionID = sessionIDFromUrl(page.url())
   if (!sessionID) throw new Error(`Failed to parse session id from url: ${page.url()}`)
-
-  await waitSessionSaved(space.directory, sessionID)
-  await createSdk(space.directory)
-    .session.abort({ sessionID })
-    .catch(() => undefined)
+  await expect(page).toHaveURL(new RegExp(`/${slug}/session/${sessionID}(?:[/?#]|$)`))
   return sessionID
 }
 
+async function sessionDirectory(directory: string, sessionID: string) {
+  const info = await createSdk(directory)
+    .session.get({ sessionID })
+    .then((x) => x.data)
+    .catch(() => undefined)
+  if (!info) return ""
+  return info.directory
+}
+
 test("new sessions from sidebar workspace actions stay in selected workspace", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
-  await withProject(async ({ slug: root, trackDirectory, trackSession }) => {
-    await openSidebar(page)
-    await setWorkspacesEnabled(page, root, true)
+  await withProject(async ({ directory, slug: root }) => {
+    const workspaces = [] as { slug: string; directory: string }[]
+    const sessions = [] as string[]
 
-    const first = await createWorkspace(page, root, [])
-    trackDirectory(first.directory)
-    await waitWorkspaceReady(page, first)
+    try {
+      await openSidebar(page)
+      await setWorkspacesEnabled(page, root, true)
 
-    const second = await createWorkspace(page, root, [first.slug])
-    trackDirectory(second.directory)
-    await waitWorkspaceReady(page, second)
+      const first = await createWorkspace(page, root, [])
+      workspaces.push(first)
+      await waitWorkspaceReady(page, first.slug)
 
-    trackSession(await createSessionFromWorkspace(page, first, `workspace one ${Date.now()}`), first.directory)
-    trackSession(await createSessionFromWorkspace(page, second, `workspace two ${Date.now()}`), second.directory)
-    trackSession(await createSessionFromWorkspace(page, first, `workspace one again ${Date.now()}`), first.directory)
+      const second = await createWorkspace(page, root, [first.slug])
+      workspaces.push(second)
+      await waitWorkspaceReady(page, second.slug)
+
+      const firstSession = await createSessionFromWorkspace(page, first.slug, `workspace one ${Date.now()}`)
+      sessions.push(firstSession)
+
+      const secondSession = await createSessionFromWorkspace(page, second.slug, `workspace two ${Date.now()}`)
+      sessions.push(secondSession)
+
+      const thirdSession = await createSessionFromWorkspace(page, first.slug, `workspace one again ${Date.now()}`)
+      sessions.push(thirdSession)
+
+      await expect.poll(() => sessionDirectory(first.directory, firstSession)).toBe(first.directory)
+      await expect.poll(() => sessionDirectory(second.directory, secondSession)).toBe(second.directory)
+      await expect.poll(() => sessionDirectory(first.directory, thirdSession)).toBe(first.directory)
+    } finally {
+      const dirs = [directory, ...workspaces.map((workspace) => workspace.directory)]
+      await Promise.all(
+        sessions.map((sessionID) =>
+          Promise.all(
+            dirs.map((dir) =>
+              createSdk(dir)
+                .session.delete({ sessionID })
+                .catch(() => undefined),
+            ),
+          ),
+        ),
+      )
+      await Promise.all(workspaces.map((workspace) => cleanupTestProject(workspace.directory)))
+    }
   })
 })

packages/app/e2e/projects/workspaces.spec.ts

@@ -1,7 +1,7 @@
+import { base64Decode } from "@opencode-ai/util/encode"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
-import { base64Decode } from "@opencode-ai/util/encode"
 import type { Page } from "@playwright/test"
 
 import { test, expect } from "../fixtures"
@@ -13,15 +13,15 @@ import {
   confirmDialog,
   openSidebar,
   openWorkspaceMenu,
-  resolveSlug,
   setWorkspacesEnabled,
-  slugFromUrl,
-  waitDir,
-  waitSlug,
 } from "../actions"
 import { dropdownMenuContentSelector, inlineInputSelector, workspaceItemSelector } from "../selectors"
 import { createSdk, dirSlug } from "../utils"
 
+function slugFromUrl(url: string) {
+  return /\/([^/]+)\/session(?:\/|$)/.exec(url)?.[1] ?? ""
+}
+
 async function setupWorkspaceTest(page: Page, project: { slug: string }) {
   const rootSlug = project.slug
   await openSidebar(page)
@@ -29,15 +29,25 @@ async function setupWorkspaceTest(page: Page, project: { slug: string }) {
   await setWorkspacesEnabled(page, rootSlug, true)
 
   await page.getByRole("button", { name: "New workspace" }).first().click()
-  const next = await resolveSlug(await waitSlug(page, [rootSlug]))
-  await waitDir(page, next.directory)
+  await expect
+    .poll(
+      () => {
+        const slug = slugFromUrl(page.url())
+        return slug.length > 0 && slug !== rootSlug
+      },
+      { timeout: 45_000 },
+    )
+    .toBe(true)
+
+  const slug = slugFromUrl(page.url())
+  const dir = base64Decode(slug)
 
   await openSidebar(page)
 
   await expect
     .poll(
       async () => {
-        const item = page.locator(workspaceItemSelector(next.slug)).first()
+        const item = page.locator(workspaceItemSelector(slug)).first()
         try {
           await item.hover({ timeout: 500 })
           return true
@@ -49,7 +59,7 @@ async function setupWorkspaceTest(page: Page, project: { slug: string }) {
     )
     .toBe(true)
 
-  return { rootSlug, slug: next.slug, directory: next.directory }
+  return { rootSlug, slug, directory: dir }
 }
 
 test("can enable and disable workspaces from project menu", async ({ page, withProject }) => {
@@ -81,15 +91,26 @@ test("can create a workspace", async ({ page, withProject }) => {
     await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
 
     await page.getByRole("button", { name: "New workspace" }).first().click()
-    const next = await resolveSlug(await waitSlug(page, [slug]))
-    await waitDir(page, next.directory)
+
+    await expect
+      .poll(
+        () => {
+          const currentSlug = slugFromUrl(page.url())
+          return currentSlug.length > 0 && currentSlug !== slug
+        },
+        { timeout: 45_000 },
+      )
+      .toBe(true)
+
+    const workspaceSlug = slugFromUrl(page.url())
+    const workspaceDir = base64Decode(workspaceSlug)
 
     await openSidebar(page)
 
     await expect
       .poll(
         async () => {
-          const item = page.locator(workspaceItemSelector(next.slug)).first()
+          const item = page.locator(workspaceItemSelector(workspaceSlug)).first()
           try {
             await item.hover({ timeout: 500 })
             return true
@@ -101,9 +122,9 @@ test("can create a workspace", async ({ page, withProject }) => {
       )
       .toBe(true)
 
-    await expect(page.locator(workspaceItemSelector(next.slug)).first()).toBeVisible()
+    await expect(page.locator(workspaceItemSelector(workspaceSlug)).first()).toBeVisible()
 
-    await cleanupTestProject(next.directory)
+    await cleanupTestProject(workspaceDir)
   })
 })
 
@@ -121,7 +142,7 @@ test("non-git projects keep workspace mode disabled", async ({ page, withProject
 
       await expect.poll(() => slugFromUrl(page.url()), { timeout: 30_000 }).not.toBe("")
 
-      const activeDir = await resolveSlug(slugFromUrl(page.url())).then((item) => item.directory)
+      const activeDir = base64Decode(slugFromUrl(page.url()))
       expect(path.basename(activeDir)).toContain("opencode-e2e-project-nongit-")
 
       await openSidebar(page)
@@ -258,7 +279,7 @@ test("can delete a workspace", async ({ page, withProject }) => {
     await clickMenuItem(menu, /^Delete$/i, { force: true })
     await confirmDialog(page, /^Delete workspace$/i)
 
-    await expect.poll(() => base64Decode(slugFromUrl(page.url()))).toBe(project.directory)
+    await expect(page).toHaveURL(new RegExp(`/${rootSlug}/session`))
 
     await expect
       .poll(
@@ -315,6 +336,9 @@ test("can reorder workspaces by drag and drop", async ({ page, withProject }) =>
       const src = page.locator(workspaceItemSelector(from)).first()
       const dst = page.locator(workspaceItemSelector(to)).first()
 
+      await src.scrollIntoViewIfNeeded()
+      await dst.scrollIntoViewIfNeeded()
+
       const a = await src.boundingBox()
       const b = await dst.boundingBox()
       if (!a || !b) throw new Error("Failed to resolve workspace drag bounds")
@@ -333,9 +357,19 @@ test("can reorder workspaces by drag and drop", async ({ page, withProject }) =>
       for (const _ of [0, 1]) {
         const prev = slugFromUrl(page.url())
         await page.getByRole("button", { name: "New workspace" }).first().click()
-        const next = await resolveSlug(await waitSlug(page, [rootSlug, prev]))
-        await waitDir(page, next.directory)
-        workspaces.push(next)
+        await expect
+          .poll(
+            () => {
+              const slug = slugFromUrl(page.url())
+              return slug.length > 0 && slug !== rootSlug && slug !== prev
+            },
+            { timeout: 45_000 },
+          )
+          .toBe(true)
+
+        const slug = slugFromUrl(page.url())
+        const dir = base64Decode(slug)
+        workspaces.push({ slug, directory: dir })
 
         await openSidebar(page)
       }

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

@@ -1,8 +1,6 @@
 import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
-import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"
-
-const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()
+import { sessionIDFromUrl } from "../actions"
 
 // Regression test for Issue #12453: the synchronous POST /message endpoint holds
 // the connection open while the agent works, causing "Failed to fetch" over
@@ -40,37 +38,6 @@ test("prompt succeeds when sync message endpoint is unreachable", async ({ page,
       )
       .toContain(token)
   } finally {
-    await cleanupSession({ sdk, sessionID })
+    await sdk.session.delete({ sessionID }).catch(() => undefined)
   }
 })
-
-test("failed prompt send restores the composer input", async ({ page, sdk, gotoSession }) => {
-  await withSession(sdk, `e2e prompt failure ${Date.now()}`, async (session) => {
-    const prompt = page.locator(promptSelector)
-    const value = `restore ${Date.now()}`
-
-    await page.route(`**/session/${session.id}/prompt_async`, (route) =>
-      route.fulfill({
-        status: 500,
-        contentType: "application/json",
-        body: JSON.stringify({ message: "e2e prompt failure" }),
-      }),
-    )
-
-    await gotoSession(session.id)
-    await prompt.click()
-    await page.keyboard.type(value)
-    await page.keyboard.press("Enter")
-
-    await expect.poll(async () => text(await prompt.textContent())).toBe(value)
-    await expect
-      .poll(
-        async () => {
-          const messages = await sdk.session.messages({ sessionID: session.id, limit: 50 }).then((r) => r.data ?? [])
-          return messages.length
-        },
-        { timeout: 15_000 },
-      )
-      .toBe(0)
-  })
-})

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

@@ -1,184 +0,0 @@
-import type { ToolPart } from "@opencode-ai/sdk/v2/client"
-import type { Page } from "@playwright/test"
-import { test, expect } from "../fixtures"
-import { withSession } from "../actions"
-import { promptSelector } from "../selectors"
-
-const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()
-
-const isBash = (part: unknown): part is ToolPart => {
-  if (!part || typeof part !== "object") return false
-  if (!("type" in part) || part.type !== "tool") return false
-  if (!("tool" in part) || part.tool !== "bash") return false
-  return "state" in part
-}
-
-async function edge(page: Page, pos: "start" | "end") {
-  await page.locator(promptSelector).evaluate((el: HTMLDivElement, pos: "start" | "end") => {
-    const selection = window.getSelection()
-    if (!selection) return
-
-    const walk = document.createTreeWalker(el, NodeFilter.SHOW_TEXT)
-    const nodes: Text[] = []
-    for (let node = walk.nextNode(); node; node = walk.nextNode()) {
-      nodes.push(node as Text)
-    }
-
-    if (nodes.length === 0) {
-      const node = document.createTextNode("")
-      el.appendChild(node)
-      nodes.push(node)
-    }
-
-    const node = pos === "start" ? nodes[0]! : nodes[nodes.length - 1]!
-    const range = document.createRange()
-    range.setStart(node, pos === "start" ? 0 : (node.textContent ?? "").length)
-    range.collapse(true)
-    selection.removeAllRanges()
-    selection.addRange(range)
-  }, pos)
-}
-
-async function wait(page: Page, value: string) {
-  await expect.poll(async () => text(await page.locator(promptSelector).textContent())).toBe(value)
-}
-
-async function reply(sdk: Parameters<typeof withSession>[0], sessionID: string, token: string) {
-  await expect
-    .poll(
-      async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
-        return messages
-          .filter((item) => item.info.role === "assistant")
-          .flatMap((item) => item.parts)
-          .filter((item) => item.type === "text")
-          .map((item) => item.text)
-          .join("\n")
-      },
-      { timeout: 90_000 },
-    )
-    .toContain(token)
-}
-
-async function shell(sdk: Parameters<typeof withSession>[0], sessionID: string, cmd: string, token: string) {
-  await expect
-    .poll(
-      async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
-        const part = messages
-          .filter((item) => item.info.role === "assistant")
-          .flatMap((item) => item.parts)
-          .filter(isBash)
-          .find((item) => item.state.input?.command === cmd && item.state.status === "completed")
-
-        if (!part || part.state.status !== "completed") return
-        return typeof part.state.metadata?.output === "string" ? part.state.metadata.output : part.state.output
-      },
-      { timeout: 90_000 },
-    )
-    .toContain(token)
-}
-
-test("prompt history restores unsent draft with arrow navigation", async ({ page, sdk, gotoSession }) => {
-  test.setTimeout(120_000)
-
-  await withSession(sdk, `e2e prompt history ${Date.now()}`, async (session) => {
-    await gotoSession(session.id)
-
-    const prompt = page.locator(promptSelector)
-    const firstToken = `E2E_HISTORY_ONE_${Date.now()}`
-    const secondToken = `E2E_HISTORY_TWO_${Date.now()}`
-    const first = `Reply with exactly: ${firstToken}`
-    const second = `Reply with exactly: ${secondToken}`
-    const draft = `draft ${Date.now()}`
-
-    await prompt.click()
-    await page.keyboard.type(first)
-    await page.keyboard.press("Enter")
-    await wait(page, "")
-    await reply(sdk, session.id, firstToken)
-
-    await prompt.click()
-    await page.keyboard.type(second)
-    await page.keyboard.press("Enter")
-    await wait(page, "")
-    await reply(sdk, session.id, secondToken)
-
-    await prompt.click()
-    await page.keyboard.type(draft)
-    await wait(page, draft)
-
-    // Clear the draft before navigating history (ArrowUp only works when prompt is empty)
-    await prompt.fill("")
-    await wait(page, "")
-
-    await page.keyboard.press("ArrowUp")
-    await wait(page, second)
-
-    await page.keyboard.press("ArrowUp")
-    await wait(page, first)
-
-    await page.keyboard.press("ArrowDown")
-    await wait(page, second)
-
-    await page.keyboard.press("ArrowDown")
-    await wait(page, "")
-  })
-})
-
-test("shell history stays separate from normal prompt history", async ({ page, sdk, gotoSession }) => {
-  test.setTimeout(120_000)
-
-  await withSession(sdk, `e2e shell history ${Date.now()}`, async (session) => {
-    await gotoSession(session.id)
-
-    const prompt = page.locator(promptSelector)
-    const firstToken = `E2E_SHELL_ONE_${Date.now()}`
-    const secondToken = `E2E_SHELL_TWO_${Date.now()}`
-    const normalToken = `E2E_NORMAL_${Date.now()}`
-    const first = `echo ${firstToken}`
-    const second = `echo ${secondToken}`
-    const normal = `Reply with exactly: ${normalToken}`
-
-    await prompt.click()
-    await page.keyboard.type("!")
-    await page.keyboard.type(first)
-    await page.keyboard.press("Enter")
-    await wait(page, "")
-    await shell(sdk, session.id, first, firstToken)
-
-    await prompt.click()
-    await page.keyboard.type("!")
-    await page.keyboard.type(second)
-    await page.keyboard.press("Enter")
-    await wait(page, "")
-    await shell(sdk, session.id, second, secondToken)
-
-    await prompt.click()
-    await page.keyboard.type("!")
-    await page.keyboard.press("ArrowUp")
-    await wait(page, second)
-
-    await page.keyboard.press("ArrowUp")
-    await wait(page, first)
-
-    await page.keyboard.press("ArrowDown")
-    await wait(page, second)
-
-    await page.keyboard.press("ArrowDown")
-    await wait(page, "")
-
-    await page.keyboard.press("Escape")
-    await wait(page, "")
-
-    await prompt.click()
-    await page.keyboard.type(normal)
-    await page.keyboard.press("Enter")
-    await wait(page, "")
-    await reply(sdk, session.id, normalToken)
-
-    await prompt.click()
-    await page.keyboard.press("ArrowUp")
-    await wait(page, normal)
-  })
-})

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

@@ -7,18 +7,12 @@ test("shift+enter inserts a newline without submitting", async ({ page, gotoSess
   await expect(page).toHaveURL(/\/session\/?$/)
 
   const prompt = page.locator(promptSelector)
-  await prompt.focus()
-  await expect(prompt).toBeFocused()
-
-  await prompt.pressSequentially("line one")
-  await expect(prompt).toBeFocused()
-
-  await prompt.press("Shift+Enter")
-  await expect(page).toHaveURL(/\/session\/?$/)
-  await expect(prompt).toBeFocused()
-
-  await prompt.pressSequentially("line two")
+  await prompt.click()
+  await page.keyboard.type("line one")
+  await page.keyboard.press("Shift+Enter")
+  await page.keyboard.type("line two")
 
   await expect(page).toHaveURL(/\/session\/?$/)
-  await expect.poll(() => prompt.evaluate((el) => el.innerText)).toBe("line one\nline two")
+  await expect(prompt).toContainText("line one")
+  await expect(prompt).toContainText("line two")
 })

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

@@ -1,62 +0,0 @@
-import type { ToolPart } from "@opencode-ai/sdk/v2/client"
-import { test, expect } from "../fixtures"
-import { sessionIDFromUrl } from "../actions"
-import { promptSelector } from "../selectors"
-import { createSdk } from "../utils"
-
-const isBash = (part: unknown): part is ToolPart => {
-  if (!part || typeof part !== "object") return false
-  if (!("type" in part) || part.type !== "tool") return false
-  if (!("tool" in part) || part.tool !== "bash") return false
-  return "state" in part
-}
-
-test("shell mode runs a command in the project directory", async ({ page, withProject }) => {
-  test.setTimeout(120_000)
-
-  await withProject(async ({ directory, gotoSession, trackSession }) => {
-    const sdk = createSdk(directory)
-    const prompt = page.locator(promptSelector)
-    const cmd = process.platform === "win32" ? "dir" : "ls"
-
-    await gotoSession()
-    await prompt.click()
-    await page.keyboard.type("!")
-    await expect(prompt).toHaveAttribute("aria-label", /enter shell command/i)
-
-    await page.keyboard.type(cmd)
-    await page.keyboard.press("Enter")
-
-    await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-
-    const id = sessionIDFromUrl(page.url())
-    if (!id) throw new Error(`Failed to parse session id from url: ${page.url()}`)
-    trackSession(id, directory)
-
-    await expect
-      .poll(
-        async () => {
-          const list = await sdk.session.messages({ sessionID: id, limit: 50 }).then((x) => x.data ?? [])
-          const msg = list.findLast(
-            (item) => item.info.role === "assistant" && "path" in item.info && item.info.path.cwd === directory,
-          )
-          if (!msg) return
-
-          const part = msg.parts
-            .filter(isBash)
-            .find((item) => item.state.input?.command === cmd && item.state.status === "completed")
-
-          if (!part || part.state.status !== "completed") return
-          const output =
-            typeof part.state.metadata?.output === "string" ? part.state.metadata.output : part.state.output
-          if (!output.includes("README.md")) return
-
-          return { cwd: directory, output }
-        },
-        { timeout: 90_000 },
-      )
-      .toEqual(expect.objectContaining({ cwd: directory, output: expect.stringContaining("README.md") }))
-
-    await expect(prompt).toHaveText("")
-  })
-})

packages/app/e2e/prompt/prompt-slash-share.spec.ts

@@ -1,64 +0,0 @@
-import { test, expect } from "../fixtures"
-import { promptSelector } from "../selectors"
-import { withSession } from "../actions"
-
-const shareDisabled = process.env.OPENCODE_DISABLE_SHARE === "true" || process.env.OPENCODE_DISABLE_SHARE === "1"
-
-async function seed(sdk: Parameters<typeof withSession>[0], sessionID: string) {
-  await sdk.session.promptAsync({
-    sessionID,
-    noReply: true,
-    parts: [{ type: "text", text: "e2e share seed" }],
-  })
-
-  await expect
-    .poll(
-      async () => {
-        const messages = await sdk.session.messages({ sessionID, limit: 1 }).then((r) => r.data ?? [])
-        return messages.length
-      },
-      { timeout: 30_000 },
-    )
-    .toBeGreaterThan(0)
-}
-
-test("/share and /unshare update session share state", async ({ page, sdk, gotoSession }) => {
-  test.skip(shareDisabled, "Share is disabled in this environment (OPENCODE_DISABLE_SHARE).")
-
-  await withSession(sdk, `e2e slash share ${Date.now()}`, async (session) => {
-    const prompt = page.locator(promptSelector)
-
-    await seed(sdk, session.id)
-    await gotoSession(session.id)
-
-    await prompt.click()
-    await page.keyboard.type("/share")
-    await expect(page.locator('[data-slash-id="session.share"]').first()).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(
-        async () => {
-          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-          return data?.share?.url || undefined
-        },
-        { timeout: 30_000 },
-      )
-      .not.toBeUndefined()
-
-    await prompt.click()
-    await page.keyboard.type("/unshare")
-    await expect(page.locator('[data-slash-id="session.unshare"]').first()).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(
-        async () => {
-          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
-          return data?.share?.url || undefined
-        },
-        { timeout: 30_000 },
-      )
-      .toBeUndefined()
-  })
-})

packages/app/e2e/prompt/prompt-slash-terminal.spec.ts

@@ -1,5 +1,4 @@
 import { test, expect } from "../fixtures"
-import { runPromptSlash, waitTerminalFocusIdle } from "../actions"
 import { promptSelector, terminalSelector } from "../selectors"
 
 test("/terminal toggles the terminal panel", async ({ page, gotoSession }) => {
@@ -10,9 +9,15 @@ test("/terminal toggles the terminal panel", async ({ page, gotoSession }) => {
 
   await expect(terminal).not.toBeVisible()
 
-  await runPromptSlash(page, { prompt, text: "/terminal", id: "terminal.toggle" })
-  await waitTerminalFocusIdle(page, { term: terminal })
+  await prompt.click()
+  await page.keyboard.type("/terminal")
+  await expect(page.locator('[data-slash-id="terminal.toggle"]').first()).toBeVisible()
+  await page.keyboard.press("Enter")
+  await expect(terminal).toBeVisible()
 
-  await runPromptSlash(page, { prompt, text: "/terminal", id: "terminal.toggle" })
+  await prompt.click()
+  await page.keyboard.type("/terminal")
+  await expect(page.locator('[data-slash-id="terminal.toggle"]').first()).toBeVisible()
+  await page.keyboard.press("Enter")
   await expect(terminal).not.toBeVisible()
 })

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

@@ -1,6 +1,6 @@
 import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
-import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"
+import { sessionIDFromUrl, withSession } from "../actions"
 
 test("can send a prompt and receive a reply", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
@@ -46,7 +46,7 @@ test("can send a prompt and receive a reply", async ({ page, sdk, gotoSession })
       .toContain(token)
   } finally {
     page.off("pageerror", onPageError)
-    await cleanupSession({ sdk, sessionID })
+    await sdk.session.delete({ sessionID }).catch(() => undefined)
   }
 
   if (pageErrors.length > 0) {

packages/app/e2e/selectors.ts

@@ -1,6 +1,5 @@
 export const promptSelector = '[data-component="prompt-input"]'
-export const terminalPanelSelector = '#terminal-panel[aria-hidden="false"]'
-export const terminalSelector = `${terminalPanelSelector} [data-component="terminal"]`
+export const terminalSelector = '[data-component="terminal"]'
 export const sessionComposerDockSelector = '[data-component="session-prompt-dock"]'
 export const questionDockSelector = '[data-component="dock-prompt"][data-kind="question"]'
 export const permissionDockSelector = '[data-component="dock-prompt"][data-kind="permission"]'
@@ -13,14 +12,10 @@ export const sessionTodoToggleButtonSelector = '[data-action="session-todo-toggl
 export const sessionTodoListSelector = '[data-slot="session-todo-list"]'
 
 export const modelVariantCycleSelector = '[data-action="model-variant-cycle"]'
-export const promptAgentSelector = '[data-component="prompt-agent-control"]'
-export const promptModelSelector = '[data-component="prompt-model-control"]'
-export const promptVariantSelector = '[data-component="prompt-variant-control"]'
 export const settingsLanguageSelectSelector = '[data-action="settings-language"]'
 export const settingsColorSchemeSelector = '[data-action="settings-color-scheme"]'
 export const settingsThemeSelector = '[data-action="settings-theme"]'
-export const settingsCodeFontSelector = '[data-action="settings-code-font"]'
-export const settingsUIFontSelector = '[data-action="settings-ui-font"]'
+export const settingsFontSelector = '[data-action="settings-font"]'
 export const settingsNotificationsAgentSelector = '[data-action="settings-notifications-agent"]'
 export const settingsNotificationsPermissionsSelector = '[data-action="settings-notifications-permissions"]'
 export const settingsNotificationsErrorsSelector = '[data-action="settings-notifications-errors"]'
@@ -35,6 +30,8 @@ export const sidebarNavSelector = '[data-component="sidebar-nav-desktop"]'
 export const projectSwitchSelector = (slug: string) =>
   `${sidebarNavSelector} [data-action="project-switch"][data-project="${slug}"]`
 
+export const projectCloseHoverSelector = (slug: string) => `[data-action="project-close-hover"][data-project="${slug}"]`
+
 export const projectMenuTriggerSelector = (slug: string) =>
   `${sidebarNavSelector} [data-action="project-menu"][data-project="${slug}"]`
 

packages/app/e2e/session/session-child-navigation.spec.ts

@@ -1,37 +0,0 @@
-import { seedSessionTask, withSession } from "../actions"
-import { test, expect } from "../fixtures"
-
-test("task tool child-session link does not trigger stale show errors", async ({ page, sdk, gotoSession }) => {
-  test.setTimeout(120_000)
-
-  const errs: string[] = []
-  const onError = (err: Error) => {
-    errs.push(err.message)
-  }
-  page.on("pageerror", onError)
-
-  await withSession(sdk, `e2e child nav ${Date.now()}`, async (session) => {
-    const child = await seedSessionTask(sdk, {
-      sessionID: session.id,
-      description: "Open child session",
-      prompt: "Search the repository for AssistantParts and then reply with exactly CHILD_OK.",
-    })
-
-    try {
-      await gotoSession(session.id)
-
-      const link = page
-        .locator("a.subagent-link")
-        .filter({ hasText: /open child session/i })
-        .first()
-      await expect(link).toBeVisible({ timeout: 30_000 })
-      await link.click()
-
-      await expect(page).toHaveURL(new RegExp(`/session/${child.sessionID}(?:[/?#]|$)`), { timeout: 30_000 })
-      await page.waitForTimeout(1000)
-      expect(errs).toEqual([])
-    } finally {
-      page.off("pageerror", onError)
-    }
-  })
-})

packages/app/e2e/session/session-composer-dock.spec.ts

@@ -1,16 +1,12 @@
 import { test, expect } from "../fixtures"
-import {
-  composerEvent,
-  type ComposerDriverState,
-  type ComposerProbeState,
-  type ComposerWindow,
-} from "../../src/testing/session-composer"
-import { cleanupSession, clearSessionDockSeed, seedSessionQuestion } from "../actions"
+import { clearSessionDockSeed, seedSessionQuestion, seedSessionTodos } from "../actions"
 import {
   permissionDockSelector,
   promptSelector,
   questionDockSelector,
   sessionComposerDockSelector,
+  sessionTodoDockSelector,
+  sessionTodoListSelector,
   sessionTodoToggleButtonSelector,
 } from "../selectors"
 
@@ -30,7 +26,7 @@ async function withDockSession<T>(
   try {
     return await fn(session)
   } finally {
-    await cleanupSession({ sdk, sessionID: session.id })
+    await sdk.session.delete({ sessionID: session.id }).catch(() => undefined)
   }
 }
 
@@ -46,8 +42,12 @@ async function withDockSeed<T>(sdk: Sdk, sessionID: string, fn: () => Promise<T>
 
 async function clearPermissionDock(page: any, label: RegExp) {
   const dock = page.locator(permissionDockSelector)
-  await expect(dock).toBeVisible()
-  await dock.getByRole("button", { name: label }).click()
+  for (let i = 0; i < 3; i++) {
+    const count = await dock.count()
+    if (count === 0) return
+    await dock.getByRole("button", { name: label }).click()
+    await page.waitForTimeout(150)
+  }
 }
 
 async function setAutoAccept(page: any, enabled: boolean) {
@@ -59,120 +59,6 @@ async function setAutoAccept(page: any, enabled: boolean) {
   await expect(button).toHaveAttribute("aria-pressed", enabled ? "true" : "false")
 }
 
-async function expectQuestionBlocked(page: any) {
-  await expect(page.locator(questionDockSelector)).toBeVisible()
-  await expect(page.locator(promptSelector)).toHaveCount(0)
-}
-
-async function expectQuestionOpen(page: any) {
-  await expect(page.locator(questionDockSelector)).toHaveCount(0)
-  await expect(page.locator(promptSelector)).toBeVisible()
-}
-
-async function expectPermissionBlocked(page: any) {
-  await expect(page.locator(permissionDockSelector)).toBeVisible()
-  await expect(page.locator(promptSelector)).toHaveCount(0)
-}
-
-async function expectPermissionOpen(page: any) {
-  await expect(page.locator(permissionDockSelector)).toHaveCount(0)
-  await expect(page.locator(promptSelector)).toBeVisible()
-}
-
-async function todoDock(page: any, sessionID: string) {
-  await page.addInitScript(() => {
-    const win = window as ComposerWindow
-    win.__opencode_e2e = {
-      ...win.__opencode_e2e,
-      composer: {
-        enabled: true,
-        sessions: {},
-      },
-    }
-  })
-
-  const write = async (driver: ComposerDriverState | undefined) => {
-    await page.evaluate(
-      (input: { event: string; sessionID: string; driver: ComposerDriverState | undefined }) => {
-        const win = window as ComposerWindow
-        const composer = win.__opencode_e2e?.composer
-        if (!composer?.enabled) throw new Error("Composer e2e driver is not enabled")
-        composer.sessions ??= {}
-        const prev = composer.sessions[input.sessionID] ?? {}
-        if (!input.driver) {
-          if (!prev.probe) {
-            delete composer.sessions[input.sessionID]
-          } else {
-            composer.sessions[input.sessionID] = { probe: prev.probe }
-          }
-        } else {
-          composer.sessions[input.sessionID] = {
-            ...prev,
-            driver: input.driver,
-          }
-        }
-        window.dispatchEvent(new CustomEvent(input.event, { detail: { sessionID: input.sessionID } }))
-      },
-      { event: composerEvent, sessionID, driver },
-    )
-  }
-
-  const read = () =>
-    page.evaluate((sessionID: string) => {
-      const win = window as ComposerWindow
-      return win.__opencode_e2e?.composer?.sessions?.[sessionID]?.probe ?? null
-    }, sessionID) as Promise<ComposerProbeState | null>
-
-  const api = {
-    async clear() {
-      await write(undefined)
-      return api
-    },
-    async open(todos: NonNullable<ComposerDriverState["todos"]>) {
-      await write({ live: true, todos })
-      return api
-    },
-    async finish(todos: NonNullable<ComposerDriverState["todos"]>) {
-      await write({ live: false, todos })
-      return api
-    },
-    async expectOpen(states: ComposerProbeState["states"]) {
-      await expect.poll(read, { timeout: 10_000 }).toMatchObject({
-        mounted: true,
-        collapsed: false,
-        hidden: false,
-        count: states.length,
-        states,
-      })
-      return api
-    },
-    async expectCollapsed(states: ComposerProbeState["states"]) {
-      await expect.poll(read, { timeout: 10_000 }).toMatchObject({
-        mounted: true,
-        collapsed: true,
-        hidden: true,
-        count: states.length,
-        states,
-      })
-      return api
-    },
-    async expectClosed() {
-      await expect.poll(read, { timeout: 10_000 }).toMatchObject({ mounted: false })
-      return api
-    },
-    async collapse() {
-      await page.locator(sessionTodoToggleButtonSelector).click()
-      return api
-    },
-    async expand() {
-      await page.locator(sessionTodoToggleButtonSelector).click()
-      return api
-    },
-  }
-
-  return api
-}
-
 async function withMockPermission<T>(
   page: any,
   request: {
@@ -184,10 +70,8 @@ async function withMockPermission<T>(
     always?: string[]
   },
   opts: { child?: any } | undefined,
-  fn: (state: { resolved: () => Promise<void> }) => Promise<T>,
+  fn: () => Promise<T>,
 ) {
-  const listUrl = /\/permission(?:\?.*)?$/
-  const replyUrls = [/\/session\/[^/]+\/permissions\/[^/?]+(?:\?.*)?$/, /\/permission\/[^/]+\/reply(?:\?.*)?$/]
   let pending = [
     {
       ...request,
@@ -206,8 +90,7 @@ async function withMockPermission<T>(
 
   const reply = async (route: any) => {
     const url = new URL(route.request().url())
-    const parts = url.pathname.split("/").filter(Boolean)
-    const id = parts.at(-1) === "reply" ? parts.at(-2) : parts.at(-1)
+    const id = url.pathname.split("/").pop()
     pending = pending.filter((item) => item.id !== id)
     await route.fulfill({
       status: 200,
@@ -216,10 +99,8 @@ async function withMockPermission<T>(
     })
   }
 
-  await page.route(listUrl, list)
-  for (const item of replyUrls) {
-    await page.route(item, reply)
-  }
+  await page.route("**/permission", list)
+  await page.route("**/session/*/permissions/*", reply)
 
   const sessionList = opts?.child
     ? async (route: any) => {
@@ -238,19 +119,11 @@ async function withMockPermission<T>(
 
   if (sessionList) await page.route("**/session?*", sessionList)
 
-  const state = {
-    async resolved() {
-      await expect.poll(() => pending.length, { timeout: 10_000 }).toBe(0)
-    },
-  }
-
   try {
-    return await fn(state)
+    return await fn()
   } finally {
-    await page.unroute(listUrl, list)
-    for (const item of replyUrls) {
-      await page.unroute(item, reply)
-    }
+    await page.unroute("**/permission", list)
+    await page.unroute("**/session/*/permissions/*", reply)
     if (sessionList) await page.unroute("**/session?*", sessionList)
   }
 }
@@ -300,12 +173,14 @@ test("blocked question flow unblocks after submit", async ({ page, sdk, gotoSess
       })
 
       const dock = page.locator(questionDockSelector)
-      await expectQuestionBlocked(page)
+      await expect.poll(() => dock.count(), { timeout: 10_000 }).toBe(1)
+      await expect(page.locator(promptSelector)).toHaveCount(0)
 
       await dock.locator('[data-slot="question-option"]').first().click()
       await dock.getByRole("button", { name: /submit/i }).click()
 
-      await expectQuestionOpen(page)
+      await expect.poll(() => page.locator(questionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+      await expect(page.locator(promptSelector)).toBeVisible()
     })
   })
 })
@@ -324,14 +199,15 @@ test("blocked permission flow supports allow once", async ({ page, sdk, gotoSess
         metadata: { description: "Need permission for command" },
       },
       undefined,
-      async (state) => {
+      async () => {
         await page.goto(page.url())
-        await expectPermissionBlocked(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(1)
+        await expect(page.locator(promptSelector)).toHaveCount(0)
 
         await clearPermissionDock(page, /allow once/i)
-        await state.resolved()
         await page.goto(page.url())
-        await expectPermissionOpen(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+        await expect(page.locator(promptSelector)).toBeVisible()
       },
     )
   })
@@ -350,14 +226,15 @@ test("blocked permission flow supports reject", async ({ page, sdk, gotoSession
         patterns: ["/tmp/opencode-e2e-perm-reject"],
       },
       undefined,
-      async (state) => {
+      async () => {
         await page.goto(page.url())
-        await expectPermissionBlocked(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(1)
+        await expect(page.locator(promptSelector)).toHaveCount(0)
 
         await clearPermissionDock(page, /deny/i)
-        await state.resolved()
         await page.goto(page.url())
-        await expectPermissionOpen(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+        await expect(page.locator(promptSelector)).toBeVisible()
       },
     )
   })
@@ -377,14 +254,15 @@ test("blocked permission flow supports allow always", async ({ page, sdk, gotoSe
         metadata: { description: "Need permission for command" },
       },
       undefined,
-      async (state) => {
+      async () => {
         await page.goto(page.url())
-        await expectPermissionBlocked(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(1)
+        await expect(page.locator(promptSelector)).toHaveCount(0)
 
         await clearPermissionDock(page, /allow always/i)
-        await state.resolved()
         await page.goto(page.url())
-        await expectPermissionOpen(page)
+        await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+        await expect(page.locator(promptSelector)).toBeVisible()
       },
     )
   })
@@ -423,15 +301,17 @@ test("child session question request blocks parent dock and unblocks after submi
         })
 
         const dock = page.locator(questionDockSelector)
-        await expectQuestionBlocked(page)
+        await expect.poll(() => dock.count(), { timeout: 10_000 }).toBe(1)
+        await expect(page.locator(promptSelector)).toHaveCount(0)
 
         await dock.locator('[data-slot="question-option"]').first().click()
         await dock.getByRole("button", { name: /submit/i }).click()
 
-        await expectQuestionOpen(page)
+        await expect.poll(() => page.locator(questionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+        await expect(page.locator(promptSelector)).toBeVisible()
       })
     } finally {
-      await cleanupSession({ sdk, sessionID: child.id })
+      await sdk.session.delete({ sessionID: child.id }).catch(() => undefined)
     }
   })
 })
@@ -464,50 +344,57 @@ test("child session permission request blocks parent dock and supports allow onc
           metadata: { description: "Need child permission" },
         },
         { child },
-        async (state) => {
+        async () => {
           await page.goto(page.url())
-          await expectPermissionBlocked(page)
+          const dock = page.locator(permissionDockSelector)
+          await expect.poll(() => dock.count(), { timeout: 10_000 }).toBe(1)
+          await expect(page.locator(promptSelector)).toHaveCount(0)
 
           await clearPermissionDock(page, /allow once/i)
-          await state.resolved()
           await page.goto(page.url())
 
-          await expectPermissionOpen(page)
+          await expect.poll(() => page.locator(permissionDockSelector).count(), { timeout: 10_000 }).toBe(0)
+          await expect(page.locator(promptSelector)).toBeVisible()
         },
       )
     } finally {
-      await cleanupSession({ sdk, sessionID: child.id })
+      await sdk.session.delete({ sessionID: child.id }).catch(() => undefined)
     }
   })
 })
 
 test("todo dock transitions and collapse behavior", async ({ page, sdk, gotoSession }) => {
   await withDockSession(sdk, "e2e composer dock todo", async (session) => {
-    const dock = await todoDock(page, session.id)
-    await gotoSession(session.id)
-    await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
+    await withDockSeed(sdk, session.id, async () => {
+      await gotoSession(session.id)
 
-    try {
-      await dock.open([
-        { content: "first task", status: "pending", priority: "high" },
-        { content: "second task", status: "in_progress", priority: "medium" },
-      ])
-      await dock.expectOpen(["pending", "in_progress"])
+      await seedSessionTodos(sdk, {
+        sessionID: session.id,
+        todos: [
+          { content: "first task", status: "pending", priority: "high" },
+          { content: "second task", status: "in_progress", priority: "medium" },
+        ],
+      })
 
-      await dock.collapse()
-      await dock.expectCollapsed(["pending", "in_progress"])
+      await expect.poll(() => page.locator(sessionTodoDockSelector).count(), { timeout: 10_000 }).toBe(1)
+      await expect(page.locator(sessionTodoListSelector)).toBeVisible()
 
-      await dock.expand()
-      await dock.expectOpen(["pending", "in_progress"])
+      await page.locator(sessionTodoToggleButtonSelector).click()
+      await expect(page.locator(sessionTodoListSelector)).toBeHidden()
 
-      await dock.finish([
-        { content: "first task", status: "completed", priority: "high" },
-        { content: "second task", status: "cancelled", priority: "medium" },
-      ])
-      await dock.expectClosed()
-    } finally {
-      await dock.clear()
-    }
+      await page.locator(sessionTodoToggleButtonSelector).click()
+      await expect(page.locator(sessionTodoListSelector)).toBeVisible()
+
+      await seedSessionTodos(sdk, {
+        sessionID: session.id,
+        todos: [
+          { content: "first task", status: "completed", priority: "high" },
+          { content: "second task", status: "cancelled", priority: "medium" },
+        ],
+      })
+
+      await expect.poll(() => page.locator(sessionTodoDockSelector).count(), { timeout: 10_000 }).toBe(0)
+    })
   })
 })
 
@@ -527,7 +414,8 @@ test("keyboard focus stays off prompt while blocked", async ({ page, sdk, gotoSe
         ],
       })
 
-      await expectQuestionBlocked(page)
+      await expect.poll(() => page.locator(questionDockSelector).count(), { timeout: 10_000 }).toBe(1)
+      await expect(page.locator(promptSelector)).toHaveCount(0)
 
       await page.locator("main").click({ position: { x: 5, y: 5 } })
       await page.keyboard.type("abc")

packages/app/e2e/session/session-model-persistence.spec.ts

@@ -1,405 +0,0 @@
-import type { Locator, Page } from "@playwright/test"
-import { test, expect } from "../fixtures"
-import {
-  openSidebar,
-  resolveSlug,
-  sessionIDFromUrl,
-  setWorkspacesEnabled,
-  waitSession,
-  waitSessionIdle,
-  waitSlug,
-} from "../actions"
-import {
-  promptAgentSelector,
-  promptModelSelector,
-  promptSelector,
-  promptVariantSelector,
-  workspaceItemSelector,
-  workspaceNewSessionSelector,
-} from "../selectors"
-import { createSdk, sessionPath } from "../utils"
-
-type Footer = {
-  agent: string
-  model: string
-  variant: string
-}
-
-type Probe = {
-  dir?: string
-  sessionID?: string
-  agent?: string
-  model?: { providerID: string; modelID: string; name?: string }
-  variant?: string | null
-  pick?: {
-    agent?: string
-    model?: { providerID: string; modelID: string }
-    variant?: string | null
-  }
-  variants?: string[]
-  models?: Array<{ providerID: string; modelID: string; name: string }>
-  agents?: Array<{ name: string }>
-}
-
-const escape = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-
-const text = async (locator: Locator) => ((await locator.textContent()) ?? "").trim()
-
-const modelKey = (state: Probe | null) => (state?.model ? `${state.model.providerID}:${state.model.modelID}` : null)
-
-async function probe(page: Page): Promise<Probe | null> {
-  return page.evaluate(() => {
-    const win = window as Window & {
-      __opencode_e2e?: {
-        model?: {
-          current?: Probe
-        }
-      }
-    }
-    return win.__opencode_e2e?.model?.current ?? null
-  })
-}
-
-async function currentModel(page: Page) {
-  await expect.poll(() => probe(page).then(modelKey), { timeout: 30_000 }).not.toBe(null)
-  const value = await probe(page).then(modelKey)
-  if (!value) throw new Error("Failed to resolve current model key")
-  return value
-}
-
-async function waitControl(page: Page, key: "setAgent" | "setModel" | "setVariant") {
-  await expect
-    .poll(
-      () =>
-        page.evaluate((key) => {
-          const win = window as Window & {
-            __opencode_e2e?: {
-              model?: {
-                controls?: Record<string, unknown>
-              }
-            }
-          }
-          return !!win.__opencode_e2e?.model?.controls?.[key]
-        }, key),
-      { timeout: 30_000 },
-    )
-    .toBe(true)
-}
-
-async function pickAgent(page: Page, value: string) {
-  await waitControl(page, "setAgent")
-  await page.evaluate((value) => {
-    const win = window as Window & {
-      __opencode_e2e?: {
-        model?: {
-          controls?: {
-            setAgent?: (value: string | undefined) => void
-          }
-        }
-      }
-    }
-    const fn = win.__opencode_e2e?.model?.controls?.setAgent
-    if (!fn) throw new Error("Model e2e agent control is not enabled")
-    fn(value)
-  }, value)
-}
-
-async function pickModel(page: Page, value: { providerID: string; modelID: string }) {
-  await waitControl(page, "setModel")
-  await page.evaluate((value) => {
-    const win = window as Window & {
-      __opencode_e2e?: {
-        model?: {
-          controls?: {
-            setModel?: (value: { providerID: string; modelID: string } | undefined) => void
-          }
-        }
-      }
-    }
-    const fn = win.__opencode_e2e?.model?.controls?.setModel
-    if (!fn) throw new Error("Model e2e model control is not enabled")
-    fn(value)
-  }, value)
-}
-
-async function pickVariant(page: Page, value: string) {
-  await waitControl(page, "setVariant")
-  await page.evaluate((value) => {
-    const win = window as Window & {
-      __opencode_e2e?: {
-        model?: {
-          controls?: {
-            setVariant?: (value: string | undefined) => void
-          }
-        }
-      }
-    }
-    const fn = win.__opencode_e2e?.model?.controls?.setVariant
-    if (!fn) throw new Error("Model e2e variant control is not enabled")
-    fn(value)
-  }, value)
-}
-
-async function read(page: Page): Promise<Footer> {
-  return {
-    agent: await text(page.locator(`${promptAgentSelector} [data-slot="select-select-trigger-value"]`).first()),
-    model: await text(page.locator(`${promptModelSelector} [data-action="prompt-model"] span`).first()),
-    variant: await text(page.locator(`${promptVariantSelector} [data-slot="select-select-trigger-value"]`).first()),
-  }
-}
-
-async function waitFooter(page: Page, expected: Partial<Footer>) {
-  let hit: Footer | null = null
-  await expect
-    .poll(
-      async () => {
-        const state = await read(page)
-        const ok = Object.entries(expected).every(([key, value]) => state[key as keyof Footer] === value)
-        if (ok) hit = state
-        return ok
-      },
-      { timeout: 30_000 },
-    )
-    .toBe(true)
-  if (!hit) throw new Error("Failed to resolve prompt footer state")
-  return hit
-}
-
-async function waitModel(page: Page, value: string) {
-  await expect.poll(() => probe(page).then(modelKey), { timeout: 30_000 }).toBe(value)
-}
-
-async function choose(page: Page, root: string, value: string) {
-  const select = page.locator(root)
-  await expect(select).toBeVisible()
-  await pickAgent(page, value)
-}
-
-async function variantCount(page: Page) {
-  return (await probe(page))?.variants?.length ?? 0
-}
-
-async function agents(page: Page) {
-  return ((await probe(page))?.agents ?? []).map((item) => item.name).filter(Boolean)
-}
-
-async function ensureVariant(page: Page, directory: string): Promise<Footer> {
-  const current = await read(page)
-  if ((await variantCount(page)) >= 2) return current
-
-  const cfg = await createSdk(directory)
-    .config.get()
-    .then((x) => x.data)
-  const visible = new Set(await agents(page))
-  const entry = Object.entries(cfg?.agent ?? {}).find((item) => {
-    const value = item[1]
-    return !!value && typeof value === "object" && "variant" in value && "model" in value && visible.has(item[0])
-  })
-  const name = entry?.[0]
-  test.skip(!name, "no agent with alternate variants available")
-  if (!name) return current
-
-  await choose(page, promptAgentSelector, name)
-  await expect.poll(() => variantCount(page), { timeout: 30_000 }).toBeGreaterThanOrEqual(2)
-  return waitFooter(page, { agent: name })
-}
-
-async function chooseDifferentVariant(page: Page): Promise<Footer> {
-  const current = await read(page)
-  const next = (await probe(page))?.variants?.find((item) => item !== current.variant)
-  if (!next) throw new Error("Current model has no alternate variant to select")
-
-  await pickVariant(page, next)
-  return waitFooter(page, { agent: current.agent, model: current.model, variant: next })
-}
-
-async function chooseOtherModel(page: Page, skip: string[] = []): Promise<Footer> {
-  const current = await currentModel(page)
-  const next = (await probe(page))?.models?.find((item) => {
-    const key = `${item.providerID}:${item.modelID}`
-    return key !== current && !skip.includes(key)
-  })
-  if (!next) throw new Error("Failed to choose a different model")
-  await pickModel(page, { providerID: next.providerID, modelID: next.modelID })
-  await expect.poll(async () => (await read(page)).model, { timeout: 30_000 }).toBe(next.name)
-  return read(page)
-}
-
-async function goto(page: Page, directory: string, sessionID?: string) {
-  await page.goto(sessionPath(directory, sessionID))
-  await waitSession(page, { directory, sessionID })
-}
-
-async function submit(page: Page, value: string) {
-  const prompt = page.locator(promptSelector)
-  await expect(prompt).toBeVisible()
-  await prompt.click()
-  await prompt.fill(value)
-  await prompt.press("Enter")
-
-  await expect.poll(() => sessionIDFromUrl(page.url()) ?? "", { timeout: 30_000 }).not.toBe("")
-  const id = sessionIDFromUrl(page.url())
-  if (!id) throw new Error(`Failed to resolve session id from ${page.url()}`)
-  return id
-}
-
-async function waitUser(directory: string, sessionID: string) {
-  const sdk = createSdk(directory)
-  await expect
-    .poll(
-      async () => {
-        const items = await sdk.session.messages({ sessionID, limit: 20 }).then((x) => x.data ?? [])
-        return items.some((item) => item.info.role === "user")
-      },
-      { timeout: 30_000 },
-    )
-    .toBe(true)
-  await sdk.session.abort({ sessionID }).catch(() => undefined)
-  await waitSessionIdle(sdk, sessionID, 30_000).catch(() => undefined)
-}
-
-async function createWorkspace(page: Page, root: string, seen: string[]) {
-  await openSidebar(page)
-  await page.getByRole("button", { name: "New workspace" }).first().click()
-
-  const next = await resolveSlug(await waitSlug(page, [root, ...seen]))
-  await waitSession(page, { directory: next.directory })
-  return next
-}
-
-async function waitWorkspace(page: Page, slug: string) {
-  await openSidebar(page)
-  await expect
-    .poll(
-      async () => {
-        const item = page.locator(workspaceItemSelector(slug)).first()
-        try {
-          await item.hover({ timeout: 500 })
-          return true
-        } catch {
-          return false
-        }
-      },
-      { timeout: 60_000 },
-    )
-    .toBe(true)
-}
-
-async function newWorkspaceSession(page: Page, slug: string) {
-  await waitWorkspace(page, slug)
-  const item = page.locator(workspaceItemSelector(slug)).first()
-  await item.hover()
-
-  const button = page.locator(workspaceNewSessionSelector(slug)).first()
-  await expect(button).toBeVisible()
-  await button.click({ force: true })
-
-  const next = await resolveSlug(await waitSlug(page))
-  return waitSession(page, { directory: next.directory }).then((item) => item.directory)
-}
-
-test("session model restore per session without leaking into new sessions", async ({ page, withProject }) => {
-  await page.setViewportSize({ width: 1440, height: 900 })
-
-  await withProject(async ({ directory, gotoSession, trackSession }) => {
-    await gotoSession()
-
-    const firstState = await chooseOtherModel(page)
-    const firstKey = await currentModel(page)
-    const first = await submit(page, `session variant ${Date.now()}`)
-    trackSession(first)
-    await waitUser(directory, first)
-
-    await page.reload()
-    await waitSession(page, { directory, sessionID: first })
-    await waitFooter(page, firstState)
-
-    await gotoSession()
-    const fresh = await read(page)
-    expect(fresh.model).not.toBe(firstState.model)
-
-    const secondState = await chooseOtherModel(page, [firstKey])
-    const second = await submit(page, `session model ${Date.now()}`)
-    trackSession(second)
-    await waitUser(directory, second)
-
-    await goto(page, directory, first)
-    await waitFooter(page, firstState)
-
-    await goto(page, directory, second)
-    await waitFooter(page, secondState)
-
-    await gotoSession()
-    await waitFooter(page, fresh)
-  })
-})
-
-test("session model restore across workspaces", async ({ page, withProject }) => {
-  await page.setViewportSize({ width: 1440, height: 900 })
-
-  await withProject(async ({ directory: root, slug, gotoSession, trackDirectory, trackSession }) => {
-    await gotoSession()
-
-    const firstState = await chooseOtherModel(page)
-    const firstKey = await currentModel(page)
-    const first = await submit(page, `root session ${Date.now()}`)
-    trackSession(first, root)
-    await waitUser(root, first)
-
-    await openSidebar(page)
-    await setWorkspacesEnabled(page, slug, true)
-
-    const one = await createWorkspace(page, slug, [])
-    const oneDir = await newWorkspaceSession(page, one.slug)
-    trackDirectory(oneDir)
-
-    const secondState = await chooseOtherModel(page, [firstKey])
-    const secondKey = await currentModel(page)
-    const second = await submit(page, `workspace one ${Date.now()}`)
-    trackSession(second, oneDir)
-    await waitUser(oneDir, second)
-
-    const two = await createWorkspace(page, slug, [one.slug])
-    const twoDir = await newWorkspaceSession(page, two.slug)
-    trackDirectory(twoDir)
-
-    const thirdState = await chooseOtherModel(page, [firstKey, secondKey])
-    const third = await submit(page, `workspace two ${Date.now()}`)
-    trackSession(third, twoDir)
-    await waitUser(twoDir, third)
-
-    await goto(page, root, first)
-    await waitFooter(page, firstState)
-
-    await goto(page, oneDir, second)
-    await waitFooter(page, secondState)
-
-    await goto(page, twoDir, third)
-    await waitFooter(page, thirdState)
-
-    await goto(page, root, first)
-    await waitFooter(page, firstState)
-  })
-})
-
-test("variant preserved when switching agent modes", async ({ page, withProject }) => {
-  await page.setViewportSize({ width: 1440, height: 900 })
-
-  await withProject(async ({ directory, gotoSession }) => {
-    await gotoSession()
-
-    await ensureVariant(page, directory)
-    const updated = await chooseDifferentVariant(page)
-
-    const available = await agents(page)
-    const other = available.find((name) => name !== updated.agent)
-    test.skip(!other, "only one agent available")
-    if (!other) return
-
-    await choose(page, promptAgentSelector, other)
-    await waitFooter(page, { agent: other, variant: updated.variant })
-
-    await choose(page, promptAgentSelector, updated.agent)
-    await waitFooter(page, { agent: updated.agent, variant: updated.variant })
-  })
-})

packages/app/e2e/session/session-review.spec.ts

@@ -1,426 +0,0 @@
-import { waitSessionIdle, withSession } from "../actions"
-import { test, expect } from "../fixtures"
-import { createSdk } from "../utils"
-
-const count = 14
-
-function body(mark: string) {
-  return [
-    `title ${mark}`,
-    `mark ${mark}`,
-    ...Array.from({ length: 32 }, (_, i) => `line ${String(i + 1).padStart(2, "0")} ${mark}`),
-  ]
-}
-
-function files(tag: string) {
-  return Array.from({ length: count }, (_, i) => {
-    const id = String(i).padStart(2, "0")
-    return {
-      file: `review-scroll-${id}.txt`,
-      mark: `${tag}-${id}`,
-    }
-  })
-}
-
-function seed(list: ReturnType<typeof files>) {
-  const out = ["*** Begin Patch"]
-
-  for (const item of list) {
-    out.push(`*** Add File: ${item.file}`)
-    for (const line of body(item.mark)) out.push(`+${line}`)
-  }
-
-  out.push("*** End Patch")
-  return out.join("\n")
-}
-
-function edit(file: string, prev: string, next: string) {
-  return ["*** Begin Patch", `*** Update File: ${file}`, "@@", `-mark ${prev}`, `+mark ${next}`, "*** End Patch"].join(
-    "\n",
-  )
-}
-
-async function patch(sdk: ReturnType<typeof createSdk>, sessionID: string, patchText: string) {
-  await sdk.session.promptAsync({
-    sessionID,
-    agent: "build",
-    system: [
-      "You are seeding deterministic e2e UI state.",
-      "Your only valid response is one apply_patch tool call.",
-      `Use this JSON input: ${JSON.stringify({ patchText })}`,
-      "Do not call any other tools.",
-      "Do not output plain text.",
-    ].join("\n"),
-    parts: [{ type: "text", text: "Apply the provided patch exactly once." }],
-  })
-
-  await waitSessionIdle(sdk, sessionID, 120_000)
-}
-
-async function show(page: Parameters<typeof test>[0]["page"]) {
-  const btn = page.getByRole("button", { name: "Toggle review" }).first()
-  await expect(btn).toBeVisible()
-  if ((await btn.getAttribute("aria-expanded")) !== "true") await btn.click()
-  await expect(btn).toHaveAttribute("aria-expanded", "true")
-}
-
-async function expand(page: Parameters<typeof test>[0]["page"]) {
-  const close = page.getByRole("button", { name: /^Collapse all$/i }).first()
-  const open = await close
-    .isVisible()
-    .then((value) => value)
-    .catch(() => false)
-
-  const btn = page.getByRole("button", { name: /^Expand all$/i }).first()
-  if (open) {
-    await close.click()
-    await expect(btn).toBeVisible()
-  }
-
-  await expect(btn).toBeVisible()
-  await btn.click()
-  await expect(close).toBeVisible()
-}
-
-async function waitMark(page: Parameters<typeof test>[0]["page"], file: string, mark: string) {
-  await page.waitForFunction(
-    ({ file, mark }) => {
-      const view = document.querySelector('[data-slot="session-review-scroll"] .scroll-view__viewport')
-      if (!(view instanceof HTMLElement)) return false
-
-      const head = Array.from(view.querySelectorAll("h3")).find(
-        (node) => node instanceof HTMLElement && node.textContent?.includes(file),
-      )
-      if (!(head instanceof HTMLElement)) return false
-
-      return Array.from(head.parentElement?.querySelectorAll("diffs-container") ?? []).some((host) => {
-        if (!(host instanceof HTMLElement)) return false
-        const root = host.shadowRoot
-        return root?.textContent?.includes(`mark ${mark}`) ?? false
-      })
-    },
-    { file, mark },
-    { timeout: 60_000 },
-  )
-}
-
-async function spot(page: Parameters<typeof test>[0]["page"], file: string) {
-  return page.evaluate((file) => {
-    const view = document.querySelector('[data-slot="session-review-scroll"] .scroll-view__viewport')
-    if (!(view instanceof HTMLElement)) return null
-
-    const row = Array.from(view.querySelectorAll("h3")).find(
-      (node) => node instanceof HTMLElement && node.textContent?.includes(file),
-    )
-    if (!(row instanceof HTMLElement)) return null
-
-    const a = row.getBoundingClientRect()
-    const b = view.getBoundingClientRect()
-    return {
-      top: a.top - b.top,
-      y: view.scrollTop,
-    }
-  }, file)
-}
-
-async function comment(page: Parameters<typeof test>[0]["page"], file: string, note: string) {
-  const row = page.locator(`[data-file="${file}"]`).first()
-  await expect(row).toBeVisible()
-
-  const line = row.locator('diffs-container [data-line="2"]').first()
-  await expect(line).toBeVisible()
-  await line.hover()
-
-  const add = row.getByRole("button", { name: /^Comment$/ }).first()
-  await expect(add).toBeVisible()
-  await add.click()
-
-  const area = row.locator('[data-slot="line-comment-textarea"]').first()
-  await expect(area).toBeVisible()
-  await area.fill(note)
-
-  const submit = row.locator('[data-slot="line-comment-action"][data-variant="primary"]').first()
-  await expect(submit).toBeEnabled()
-  await submit.click()
-
-  await expect(row.locator('[data-slot="line-comment-content"]').filter({ hasText: note }).first()).toBeVisible()
-  await expect(row.locator('[data-slot="line-comment-tools"]').first()).toBeVisible()
-}
-
-async function overflow(page: Parameters<typeof test>[0]["page"], file: string) {
-  const row = page.locator(`[data-file="${file}"]`).first()
-  const view = page.locator('[data-slot="session-review-scroll"] .scroll-view__viewport').first()
-  const pop = row.locator('[data-slot="line-comment-popover"][data-inline-body]').first()
-  const tools = row.locator('[data-slot="line-comment-tools"]').first()
-
-  const [width, viewBox, popBox, toolsBox] = await Promise.all([
-    view.evaluate((el) => el.scrollWidth - el.clientWidth),
-    view.boundingBox(),
-    pop.boundingBox(),
-    tools.boundingBox(),
-  ])
-
-  if (!viewBox || !popBox || !toolsBox) return null
-
-  return {
-    width,
-    pop: popBox.x + popBox.width - (viewBox.x + viewBox.width),
-    tools: toolsBox.x + toolsBox.width - (viewBox.x + viewBox.width),
-  }
-}
-
-async function openReviewFile(page: Parameters<typeof test>[0]["page"], file: string) {
-  const row = page.locator(`[data-file="${file}"]`).first()
-  await expect(row).toBeVisible()
-  await row.hover()
-
-  const open = row.getByRole("button", { name: /^Open file$/i }).first()
-  await expect(open).toBeVisible()
-  await open.click()
-
-  const tab = page.getByRole("tab", { name: file }).first()
-  await expect(tab).toBeVisible()
-  await tab.click()
-
-  const viewer = page.locator('[data-component="file"][data-mode="text"]').first()
-  await expect(viewer).toBeVisible()
-  return viewer
-}
-
-async function fileComment(page: Parameters<typeof test>[0]["page"], note: string) {
-  const viewer = page.locator('[data-component="file"][data-mode="text"]').first()
-  await expect(viewer).toBeVisible()
-
-  const line = viewer.locator('diffs-container [data-line="2"]').first()
-  await expect(line).toBeVisible()
-  await line.hover()
-
-  const add = viewer.getByRole("button", { name: /^Comment$/ }).first()
-  await expect(add).toBeVisible()
-  await add.click()
-
-  const area = viewer.locator('[data-slot="line-comment-textarea"]').first()
-  await expect(area).toBeVisible()
-  await area.fill(note)
-
-  const submit = viewer.locator('[data-slot="line-comment-action"][data-variant="primary"]').first()
-  await expect(submit).toBeEnabled()
-  await submit.click()
-
-  await expect(viewer.locator('[data-slot="line-comment-content"]').filter({ hasText: note }).first()).toBeVisible()
-  await expect(viewer.locator('[data-slot="line-comment-tools"]').first()).toBeVisible()
-}
-
-async function fileOverflow(page: Parameters<typeof test>[0]["page"]) {
-  const viewer = page.locator('[data-component="file"][data-mode="text"]').first()
-  const view = page.locator('[role="tabpanel"] .scroll-view__viewport').first()
-  const pop = viewer.locator('[data-slot="line-comment-popover"][data-inline-body]').first()
-  const tools = viewer.locator('[data-slot="line-comment-tools"]').first()
-
-  const [width, viewBox, popBox, toolsBox] = await Promise.all([
-    view.evaluate((el) => el.scrollWidth - el.clientWidth),
-    view.boundingBox(),
-    pop.boundingBox(),
-    tools.boundingBox(),
-  ])
-
-  if (!viewBox || !popBox || !toolsBox) return null
-
-  return {
-    width,
-    pop: popBox.x + popBox.width - (viewBox.x + viewBox.width),
-    tools: toolsBox.x + toolsBox.width - (viewBox.x + viewBox.width),
-  }
-}
-
-test("review applies inline comment clicks without horizontal overflow", async ({ page, withProject }) => {
-  test.setTimeout(180_000)
-
-  const tag = `review-comment-${Date.now()}`
-  const file = `review-comment-${tag}.txt`
-  const note = `comment ${tag}`
-
-  await page.setViewportSize({ width: 1280, height: 900 })
-
-  await withProject(async (project) => {
-    const sdk = createSdk(project.directory)
-
-    await withSession(sdk, `e2e review comment ${tag}`, async (session) => {
-      await patch(sdk, session.id, seed([{ file, mark: tag }]))
-
-      await expect
-        .poll(
-          async () => {
-            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-            return diff.length
-          },
-          { timeout: 60_000 },
-        )
-        .toBe(1)
-
-      await project.gotoSession(session.id)
-      await show(page)
-
-      const tab = page.getByRole("tab", { name: /Review/i }).first()
-      await expect(tab).toBeVisible()
-      await tab.click()
-
-      await expand(page)
-      await waitMark(page, file, tag)
-      await comment(page, file, note)
-
-      await expect
-        .poll(async () => (await overflow(page, file))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-      await expect
-        .poll(async () => (await overflow(page, file))?.pop ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-      await expect
-        .poll(async () => (await overflow(page, file))?.tools ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-    })
-  })
-})
-
-test("review file comments submit on click without clipping actions", async ({ page, withProject }) => {
-  test.setTimeout(180_000)
-
-  const tag = `review-file-comment-${Date.now()}`
-  const file = `review-file-comment-${tag}.txt`
-  const note = `comment ${tag}`
-
-  await page.setViewportSize({ width: 1280, height: 900 })
-
-  await withProject(async (project) => {
-    const sdk = createSdk(project.directory)
-
-    await withSession(sdk, `e2e review file comment ${tag}`, async (session) => {
-      await patch(sdk, session.id, seed([{ file, mark: tag }]))
-
-      await expect
-        .poll(
-          async () => {
-            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-            return diff.length
-          },
-          { timeout: 60_000 },
-        )
-        .toBe(1)
-
-      await project.gotoSession(session.id)
-      await show(page)
-
-      const tab = page.getByRole("tab", { name: /Review/i }).first()
-      await expect(tab).toBeVisible()
-      await tab.click()
-
-      await expand(page)
-      await waitMark(page, file, tag)
-      await openReviewFile(page, file)
-      await fileComment(page, note)
-
-      await expect
-        .poll(async () => (await fileOverflow(page))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-      await expect
-        .poll(async () => (await fileOverflow(page))?.pop ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-      await expect
-        .poll(async () => (await fileOverflow(page))?.tools ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-        .toBeLessThanOrEqual(1)
-    })
-  })
-})
-
-test("review keeps scroll position after a live diff update", async ({ page, withProject }) => {
-  test.skip(Boolean(process.env.CI), "Flaky in CI for now.")
-  test.setTimeout(180_000)
-
-  const tag = `review-${Date.now()}`
-  const list = files(tag)
-  const hit = list[list.length - 4]!
-  const next = `${tag}-live`
-
-  await page.setViewportSize({ width: 1600, height: 1000 })
-
-  await withProject(async (project) => {
-    const sdk = createSdk(project.directory)
-
-    await withSession(sdk, `e2e review ${tag}`, async (session) => {
-      await patch(sdk, session.id, seed(list))
-
-      await expect
-        .poll(
-          async () => {
-            const info = await sdk.session.get({ sessionID: session.id }).then((res) => res.data)
-            return info?.summary?.files ?? 0
-          },
-          { timeout: 60_000 },
-        )
-        .toBe(list.length)
-
-      await expect
-        .poll(
-          async () => {
-            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-            return diff.length
-          },
-          { timeout: 60_000 },
-        )
-        .toBe(list.length)
-
-      await project.gotoSession(session.id)
-      await show(page)
-
-      const tab = page.getByRole("tab", { name: /Review/i }).first()
-      await expect(tab).toBeVisible()
-      await tab.click()
-
-      const view = page.locator('[data-slot="session-review-scroll"] .scroll-view__viewport').first()
-      await expect(view).toBeVisible()
-      const heads = page.getByRole("heading", { level: 3 }).filter({ hasText: /^review-scroll-/ })
-      await expect(heads).toHaveCount(list.length, {
-        timeout: 60_000,
-      })
-
-      await expand(page)
-      await waitMark(page, hit.file, hit.mark)
-
-      const row = page
-        .getByRole("heading", { level: 3, name: new RegExp(hit.file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")) })
-        .first()
-      await expect(row).toBeVisible()
-      await row.evaluate((el) => el.scrollIntoView({ block: "center" }))
-
-      await expect.poll(async () => (await spot(page, hit.file))?.y ?? 0).toBeGreaterThan(200)
-      const prev = await spot(page, hit.file)
-      if (!prev) throw new Error(`missing review row for ${hit.file}`)
-
-      await patch(sdk, session.id, edit(hit.file, hit.mark, next))
-
-      await expect
-        .poll(
-          async () => {
-            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-            const item = diff.find((item) => item.file === hit.file)
-            return typeof item?.after === "string" ? item.after : ""
-          },
-          { timeout: 60_000 },
-        )
-        .toContain(`mark ${next}`)
-
-      await waitMark(page, hit.file, next)
-
-      await expect
-        .poll(
-          async () => {
-            const next = await spot(page, hit.file)
-            if (!next) return Number.POSITIVE_INFINITY
-            return Math.max(Math.abs(next.top - prev.top), Math.abs(next.y - prev.y))
-          },
-          { timeout: 60_000 },
-        )
-        .toBeLessThanOrEqual(32)
-    })
-  })
-})

packages/app/e2e/session/session-undo-redo.spec.ts

@@ -45,7 +45,7 @@ async function seedConversation(input: {
     .toBe(true)
 
   if (!userMessageID) throw new Error("Expected a user message id")
-  await expect(input.page.locator(`[data-message-id="${userMessageID}"]`)).toHaveCount(1, { timeout: 30_000 })
+  await expect(input.page.locator(`[data-message-id="${userMessageID}"]`).first()).toBeVisible({ timeout: 30_000 })
   return { prompt, userMessageID }
 }
 
@@ -123,7 +123,7 @@ test("slash redo clears revert and restores latest state", async ({ page, withPr
         .toBeUndefined()
 
       await expect(seeded.prompt).not.toContainText(token)
-      await expect(page.locator(`[data-message-id="${seeded.userMessageID}"]`)).toHaveCount(1)
+      await expect(page.locator(`[data-message-id="${seeded.userMessageID}"]`).first()).toBeVisible()
     })
   })
 })
@@ -158,8 +158,8 @@ test("slash undo/redo traverses multi-step revert stack", async ({ page, withPro
       const firstMessage = page.locator(`[data-message-id="${first.userMessageID}"]`)
       const secondMessage = page.locator(`[data-message-id="${second.userMessageID}"]`)
 
-      await expect(firstMessage).toHaveCount(1)
-      await expect(secondMessage).toHaveCount(1)
+      await expect(firstMessage.first()).toBeVisible()
+      await expect(secondMessage.first()).toBeVisible()
 
       await second.prompt.click()
       await page.keyboard.press(`${modKey}+A`)
@@ -176,7 +176,7 @@ test("slash undo/redo traverses multi-step revert stack", async ({ page, withPro
         })
         .toBe(second.userMessageID)
 
-      await expect(firstMessage).toHaveCount(1)
+      await expect(firstMessage.first()).toBeVisible()
       await expect(secondMessage).toHaveCount(0)
 
       await second.prompt.click()
@@ -210,7 +210,7 @@ test("slash undo/redo traverses multi-step revert stack", async ({ page, withPro
         })
         .toBe(second.userMessageID)
 
-      await expect(firstMessage).toHaveCount(1)
+      await expect(firstMessage.first()).toBeVisible()
       await expect(secondMessage).toHaveCount(0)
 
       await second.prompt.click()
@@ -226,8 +226,8 @@ test("slash undo/redo traverses multi-step revert stack", async ({ page, withPro
         })
         .toBeUndefined()
 
-      await expect(firstMessage).toHaveCount(1)
-      await expect(secondMessage).toHaveCount(1)
+      await expect(firstMessage.first()).toBeVisible()
+      await expect(secondMessage.first()).toBeVisible()
     })
   })
 })

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

@@ -1,5 +1,5 @@
 import { test, expect } from "../fixtures"
-import { openSettings, closeDialog, waitTerminalFocusIdle, withSession } from "../actions"
+import { openSettings, closeDialog, withSession } from "../actions"
 import { keybindButtonSelector, terminalSelector } from "../selectors"
 import { modKey } from "../utils"
 
@@ -32,19 +32,22 @@ test("changing sidebar toggle keybind works", async ({ page, gotoSession }) => {
 
   await closeDialog(page, dialog)
 
-  const button = page.getByRole("button", { name: /toggle sidebar/i }).first()
-  const initiallyClosed = (await button.getAttribute("aria-expanded")) !== "true"
+  const main = page.locator("main")
+  const initialClasses = (await main.getAttribute("class")) ?? ""
+  const initiallyClosed = initialClasses.includes("xl:border-l")
 
   await page.keyboard.press(`${modKey}+Shift+H`)
-  await expect(button).toHaveAttribute("aria-expanded", initiallyClosed ? "true" : "false")
+  await page.waitForTimeout(100)
 
-  const afterToggleClosed = (await button.getAttribute("aria-expanded")) !== "true"
+  const afterToggleClasses = (await main.getAttribute("class")) ?? ""
+  const afterToggleClosed = afterToggleClasses.includes("xl:border-l")
   expect(afterToggleClosed).toBe(!initiallyClosed)
 
   await page.keyboard.press(`${modKey}+Shift+H`)
-  await expect(button).toHaveAttribute("aria-expanded", initiallyClosed ? "false" : "true")
+  await page.waitForTimeout(100)
 
-  const finalClosed = (await button.getAttribute("aria-expanded")) !== "true"
+  const finalClasses = (await main.getAttribute("class")) ?? ""
+  const finalClosed = finalClasses.includes("xl:border-l")
   expect(finalClosed).toBe(initiallyClosed)
 })
 
@@ -241,7 +244,7 @@ test("changing file open keybind works", async ({ page, gotoSession }) => {
   await expect(keybindButton).toBeVisible()
 
   const initialKeybind = await keybindButton.textContent()
-  expect(initialKeybind).toContain("K")
+  expect(initialKeybind).toContain("P")
 
   await keybindButton.click()
   await expect(keybindButton).toHaveText(/press/i)
@@ -302,7 +305,7 @@ test("changing terminal toggle keybind works", async ({ page, gotoSession }) =>
   await expect(terminal).not.toBeVisible()
 
   await page.keyboard.press(`${modKey}+Y`)
-  await waitTerminalFocusIdle(page, { term: terminal })
+  await expect(terminal).toBeVisible()
 
   await page.keyboard.press(`${modKey}+Y`)
   await expect(terminal).not.toBeVisible()