Merge branch 'dev' into kit/effectify-plugin

Replace the legacy Instance.state() lazy-init pattern with the standard
Effect service pattern (Interface, Service class, Layer, promise facades).
Register Plugin.Service in InstanceServices and add its layer to the
instance lookup.

.github/VOUCHED.td

@@ -10,10 +10,6 @@
 adamdotdevin
 -agusbasari29 AI PR slop
 ariane-emory
--atharvau AI review spamming literally every PR
--borealbytes
--danieljoshuanazareth
--danieljoshuanazareth
 edemaine
 -florianleibert
 fwang
@@ -21,13 +17,8 @@ iamdavidhill
 jayair
 kitlangton
 kommander
--opencode2026
--opencodeengineer bot that spams issues
 r44vc0rp
 rekram1-node
--ricardo-m-l
--robinmordasiewicz
-simonklee
 -spider-yamet clawdbot/llm psychosis, spam pinging the team
 thdxr
--toastythebot
+-OpenCode2026

.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/docs-locale-sync.yml

@@ -9,8 +9,7 @@ on:
 
 jobs:
   sync-locales:
-    if: false
+    if: github.actor != 'opencode-agent[bot]'
-    #if: github.actor != 'opencode-agent[bot]'
     runs-on: blacksmith-4vcpu-ubuntu-2404
     permissions:
       contents: write
@@ -35,7 +34,7 @@ jobs:
       - name: Compute changed English docs
         id: changes
         run: |
-          FILES=$(git diff --name-only "${{ github.event.before }}" "${{ github.sha }}" -- ':(glob)packages/web/src/content/docs/*.mdx' || true)
+          FILES=$(git diff --name-only "${{ github.event.before }}" "${{ github.sha }}" -- 'packages/web/src/content/docs/*.mdx' || true)
           if [ -z "$FILES" ]; then
             echo "has_changes=false" >> "$GITHUB_OUTPUT"
             echo "No English docs changed in push range"

.github/workflows/nix-hashes.yml

@@ -17,10 +17,6 @@ on:
       - "patches/**"
       - ".github/workflows/nix-hashes.yml"
 
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
 jobs:
   # Native runners required: bun install cross-compilation flags (--os/--cpu)
   # do not produce byte-identical node_modules as native installs.
@@ -60,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/publish.yml

@@ -98,129 +98,15 @@ jobs:
       - uses: actions/upload-artifact@v4
         with:
           name: opencode-cli
-          path: |
+          path: packages/opencode/dist
-            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
-
   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:
@@ -266,14 +152,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"
@@ -312,7 +190,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,35 +246,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
-    if: github.repository == 'anomalyco/opencode'
     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:
@@ -422,6 +275,7 @@ jobs:
             target: aarch64-unknown-linux-gnu
             platform_flag: --linux
     runs-on: ${{ matrix.settings.host }}
+    # if: github.ref_name == 'beta'
     steps:
       - uses: actions/checkout@v3
 
@@ -438,14 +292,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"
@@ -480,7 +326,6 @@ jobs:
         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 }}
@@ -513,22 +358,6 @@ jobs:
         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 }}
@@ -544,10 +373,8 @@ jobs:
     needs:
       - version
       - build-cli
-      - sign-cli-windows
       - build-tauri
       - build-electron
-    if: always() && !failure() && !cancelled()
     runs-on: blacksmith-4vcpu-ubuntu-2404
     steps:
       - uses: actions/checkout@v3
@@ -584,16 +411,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:

.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/test.yml

@@ -15,10 +15,6 @@ concurrency:
 
 permissions:
   contents: read
-  checks: write
-
-env:
-  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
 
 jobs:
   unit:
@@ -41,11 +37,6 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "24"
-
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
@@ -54,39 +45,8 @@ jobs:
           git config --global user.email "bot@opencode.ai"
           git config --global user.name "opencode"
 
-      - name: Cache Turbo
-        uses: actions/cache@v4
-        with:
-          path: node_modules/.cache/turbo
-          key: turbo-${{ runner.os }}-${{ hashFiles('turbo.json', '**/package.json') }}-${{ github.sha }}
-          restore-keys: |
-            turbo-${{ runner.os }}-${{ hashFiles('turbo.json', '**/package.json') }}-
-            turbo-${{ runner.os }}-
-
       - name: Run unit tests
-        run: bun turbo test:ci
+        run: bun turbo test
-        env:
-          OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: ${{ runner.os == 'Windows' && 'true' || 'false' }}
-
-      - name: Publish unit reports
-        if: always()
-        uses: mikepenz/action-junit-report@v6
-        with:
-          report_paths: packages/*/.artifacts/unit/junit.xml
-          check_name: "unit results (${{ matrix.settings.name }})"
-          detailed_summary: true
-          include_time_in_summary: true
-          fail_on_failure: false
-
-      - name: Upload unit artifacts
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: unit-${{ matrix.settings.name }}-${{ github.run_attempt }}
-          include-hidden-files: true
-          if-no-files-found: ignore
-          retention-days: 7
-          path: packages/*/.artifacts/unit/junit.xml
 
   e2e:
     name: e2e (${{ matrix.settings.name }})
@@ -110,11 +70,6 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version: "24"
-
       - name: Setup Bun
         uses: ./.github/actions/setup-bun
 
@@ -145,17 +100,15 @@ jobs:
         run: bun --cwd packages/app test:e2e:local
         env:
           CI: true
-          PLAYWRIGHT_JUNIT_OUTPUT: e2e/junit-${{ matrix.settings.name }}.xml
         timeout-minutes: 30
 
       - name: Upload Playwright artifacts
-        if: always()
+        if: failure()
         uses: actions/upload-artifact@v4
         with:
           name: playwright-${{ matrix.settings.name }}-${{ github.run_attempt }}
           if-no-files-found: ignore
           retention-days: 7
           path: |
-            packages/app/e2e/junit-*.xml
             packages/app/e2e/test-results
             packages/app/e2e/playwright-report

.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

@@ -25,7 +25,6 @@ target
 
 # Local dev files
 opencode-dev
-UPCOMING_CHANGELOG.md
 logs/
 *.bun-build
 tsconfig.tsbuildinfo

.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/command/changelog.md

@@ -1,46 +0,0 @@
----
-model: opencode/gpt-5.4
----
-
-Create `UPCOMING_CHANGELOG.md` from the structured changelog input below.
-If `UPCOMING_CHANGELOG.md` already exists, ignore its current contents completely.
-Do not preserve, merge, or reuse text from the existing file.
-
-The input already contains the exact commit range since the last non-draft release.
-The commits are already filtered to the release-relevant packages and grouped into
-the release sections. Do not fetch GitHub releases, PRs, or build your own commit list.
-The input may also include a `## Community Contributors Input` section.
-
-Before writing any entry you keep, inspect the real diff with
-`git show --stat --format='' <hash>` or `git show --format='' <hash>` so you can
-understand the actual code changes and not just the commit message (they may be misleading).
-Do not use `git log` or author metadata when deciding attribution.
-
-Rules:
-
-- Write the final file with sections in this order:
-  `## Core`, `## TUI`, `## Desktop`, `## SDK`, `## Extensions`
-- Only include sections that have at least one notable entry
-- Keep one bullet per commit you keep
-- Skip commits that are entirely internal, CI, tests, refactors, or otherwise not user-facing
-- Start each bullet with a capital letter
-- Prefer what changed for users over what code changed internally
-- Do not copy raw commit prefixes like `fix:` or `feat:` or trailing PR numbers like `(#123)`
-- Community attribution is deterministic: only preserve an existing `(@username)` suffix from the changelog input
-- If an input bullet has no `(@username)` suffix, do not add one
-- Never add a new `(@username)` suffix from `git show`, commit authors, names, or email addresses
-- If no notable entries remain and there is no contributor block, write exactly `No notable changes.`
-- If no notable entries remain but there is a contributor block, omit all release sections and return only the contributor block
-- If the input contains `## Community Contributors Input`, append the block below that heading to the end of the final file verbatim
-- Do not add, remove, rewrite, or reorder contributor names or commit titles in that block
-- Do not derive the thank-you section from the main summary bullets
-- Do not include the heading `## Community Contributors Input` in the final file
-- Focus on writing the least words to get your point across - users will skim read the changelog, so we should be precise
-
-**Importantly, the changelog is for users (who are at least slightly technical), they may use the TUI, Desktop, SDK, Plugins and so forth. Be thorough in understanding flow on effects may not be immediately apparent. e.g. a package upgrade looks internal but may patch a bug. Or a refactor may also stabilise some race condition that fixes bugs for users. The PR title/body + commit message will give you the authors context, usually containing the outcome not just technical detail**
-
-<changelog_input>
-
-!`bun script/raw-changelog.ts $ARGUMENTS`
-
-</changelog_input>

.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,937 +0,0 @@
-/** @jsxImportSource @opentui/solid */
-import { useKeyboard, useTerminalDimensions, type JSX } 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 = (api: TuiPluginApi, input: Cfg) => ({
-  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_prompt(ctx, value) {
-      const skin = look(ctx.theme.current)
-      type Prompt = (props: {
-        workspaceID?: string
-        visible?: boolean
-        disabled?: boolean
-        onSubmit?: () => void
-        hint?: JSX.Element
-        right?: JSX.Element
-        showPlaceholder?: boolean
-        placeholders?: {
-          normal?: string[]
-          shell?: string[]
-        }
-      }) => JSX.Element
-      type Slot = (
-        props: { name: string; mode?: unknown; children?: JSX.Element } & Record<string, unknown>,
-      ) => JSX.Element | null
-      const ui = api.ui as TuiPluginApi["ui"] & { Prompt: Prompt; Slot: Slot }
-      const Prompt = ui.Prompt
-      const Slot = ui.Slot
-      const normal = [
-        `[SMOKE] route check for ${input.label}`,
-        "[SMOKE] confirm home_prompt slot override",
-        "[SMOKE] verify prompt-right slot passthrough",
-      ]
-      const shell = ["printf '[SMOKE] home prompt\n'", "git status --short", "bun --version"]
-      const hint = (
-        <box flexShrink={0} flexDirection="row" gap={1}>
-          <text fg={skin.muted}>
-            <span style={{ fg: skin.accent }}>•</span> smoke home prompt
-          </text>
-        </box>
-      )
-
-      return (
-        <Prompt
-          workspaceID={value.workspace_id}
-          hint={hint}
-          right={
-            <box flexDirection="row" gap={1}>
-              <Slot name="home_prompt_right" workspace_id={value.workspace_id} />
-              <Slot name="smoke_prompt_right" workspace_id={value.workspace_id} label={input.label} />
-            </box>
-          }
-          placeholders={{ normal, shell }}
-        />
-      )
-    },
-    home_prompt_right(ctx, value) {
-      const skin = look(ctx.theme.current)
-      const id = value.workspace_id?.slice(0, 8) ?? "none"
-      return (
-        <text fg={skin.muted}>
-          <span style={{ fg: skin.accent }}>{input.label}</span> home:{id}
-        </text>
-      )
-    },
-    session_prompt_right(ctx, value) {
-      const skin = look(ctx.theme.current)
-      return (
-        <text fg={skin.muted}>
-          <span style={{ fg: skin.accent }}>{input.label}</span> session:{value.session_id.slice(0, 8)}
-        </text>
-      )
-    },
-    smoke_prompt_right(ctx, value) {
-      const skin = look(ctx.theme.current)
-      const id = typeof value.workspace_id === "string" ? value.workspace_id.slice(0, 8) : "none"
-      const label = typeof value.label === "string" ? value.label : input.label
-      return (
-        <text fg={skin.muted}>
-          <span style={{ fg: skin.accent }}>{label}</span> custom:{id}
-        </text>
-      )
-    },
-    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 = (api: TuiPluginApi, input: Cfg): TuiSlotPlugin[] => [
-  home(api, 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(api, 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/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"

README.zh.md

@@ -137,4 +137,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)
+**加入我们的社区** [飞书](https://applink.feishu.cn/client/chat/chatter/add_by_link?link_token=de8k6664-1b5e-43f2-8efd-21d6772647b5&qr_code=true) | [X.com](https://x.com/opencode)

README.zht.md

@@ -137,4 +137,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)
+**加入我們的社群** [飞书](https://applink.feishu.cn/client/chat/chatter/add_by_link?link_token=de8k6664-1b5e-43f2-8efd-21d6772647b5&qr_code=true) | [X.com](https://x.com/opencode)

flake.lock

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

github/index.ts

@@ -496,6 +496,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

@@ -109,12 +109,6 @@ const zenLiteCouponFirstMonth50 = new stripe.Coupon("ZenLiteCouponFirstMonth50",
   appliesToProducts: [zenLiteProduct.id],
   duration: "once",
 })
-const zenLiteCouponFirstMonth100 = new stripe.Coupon("ZenLiteCouponFirstMonth100", {
-  name: "First month 100% off",
-  percentOff: 100,
-  appliesToProducts: [zenLiteProduct.id],
-  duration: "once",
-})
 const zenLitePrice = new stripe.Price("ZenLitePrice", {
   product: zenLiteProduct.id,
   currency: "usd",
@@ -130,7 +124,6 @@ const ZEN_LITE_PRICE = new sst.Linkable("ZEN_LITE_PRICE", {
     price: zenLitePrice.id,
     priceInr: 92900,
     firstMonth50Coupon: zenLiteCouponFirstMonth50.id,
-    firstMonth100Coupon: zenLiteCouponFirstMonth100.id,
   },
 })
 
@@ -236,7 +229,6 @@ new sst.cloudflare.x.SolidStart("Console", {
     SALESFORCE_INSTANCE_URL,
     ZEN_BLACK_PRICE,
     ZEN_LITE_PRICE,
-    new sst.Secret("ZEN_LITE_COUPON_FIRST_MONTH_100_INVITEES"),
     new sst.Secret("ZEN_LIMITS"),
     new sst.Secret("ZEN_SESSION_SECRET"),
     ...ZEN_MODELS,

nix/hashes.json

@@ -1,8 +1,8 @@
 {
   "nodeModules": {
-    "x86_64-linux": "sha256-g29OM3dy+sZ3ioTs8zjQOK1N+KnNr9ptP9xtdPcdr64=",
+    "x86_64-linux": "sha256-P0RJfQF8APTYVGP6hLJRrOkRSl5nVDNxdcGcZECPPJE=",
-    "aarch64-linux": "sha256-Iu91KwDcV5omkf4Ngny1aYpyCkPLjuoWOVUDOJUhW1k=",
+    "aarch64-linux": "sha256-ZtMjTcd35X3JhJIdn3DilFsp7i/IZIcNaKZFnSzW/nk=",
-    "aarch64-darwin": "sha256-bk3G6m+Yo60Ea3Kyglc37QZf5Vm7MLMFcxemjc7HnL0=",
+    "aarch64-darwin": "sha256-Uw/okFDRxxKQMfEsj8MXuHyhpugxZGgIKtu89Getlz8=",
-    "x86_64-darwin": "sha256-y3hooQw13Z3Cu0KFfXYdpkTEeKTyuKd+a/jsXHQLdqA="
+    "x86_64-darwin": "sha256-ZySIgT1HbWZWnaQ0W0eURKC43BTupRmmply92JDFPWA="
   }
 }

nix/node_modules.nix

@@ -20,7 +20,7 @@ let
 in
 stdenvNoCC.mkDerivation {
   pname = "opencode-node_modules";
-  version = "${packageJson.version}+${lib.replaceString "-" "." rev}";
+  version = "${packageJson.version}-${rev}";
 
   src = lib.fileset.toSource {
     root = ../.;
@@ -54,7 +54,6 @@ stdenvNoCC.mkDerivation {
       --filter '!./' \
       --filter './packages/opencode' \
       --filter './packages/desktop' \
-      --filter './packages/app' \
       --frozen-lockfile \
       --ignore-scripts \
       --no-progress

nix/opencode.nix

@@ -3,7 +3,6 @@
   stdenvNoCC,
   callPackage,
   bun,
-  nodejs,
   sysctl,
   makeBinaryWrapper,
   models-dev,
@@ -20,7 +19,6 @@ stdenvNoCC.mkDerivation (finalAttrs: {
 
   nativeBuildInputs = [
     bun
-    nodejs # for patchShebangs node_modules
     installShellFiles
     makeBinaryWrapper
     models-dev
@@ -31,8 +29,6 @@ stdenvNoCC.mkDerivation (finalAttrs: {
     runHook preConfigure
 
     cp -R ${finalAttrs.node_modules}/. .
-    patchShebangs node_modules
-    patchShebangs packages/*/node_modules
 
     runHook postConfigure
   '';

package.json

@@ -4,7 +4,7 @@
   "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",
@@ -12,7 +12,6 @@
     "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",
-    "postinstall": "bun run --cwd packages/opencode fix-node-pty",
     "prepare": "husky",
     "random": "echo 'Random script'",
     "hello": "echo 'Hello World!'",
@@ -26,9 +25,8 @@
       "packages/slack"
     ],
     "catalog": {
-      "@effect/platform-node": "4.0.0-beta.46",
+      "@effect/platform-node": "4.0.0-beta.35",
-      "@types/bun": "1.3.11",
+      "@types/bun": "1.3.9",
-      "@types/cross-spawn": "6.0.6",
       "@octokit/rest": "22.0.0",
       "@hono/zod-validator": "0.4.2",
       "ulid": "3.0.1",
@@ -47,16 +45,14 @@
       "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.46",
+      "effect": "4.0.0-beta.35",
-      "ai": "6.0.158",
+      "ai": "5.0.124",
-      "cross-spawn": "7.0.6",
       "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",
@@ -71,8 +67,7 @@
       "@solidjs/router": "0.15.4",
       "@solidjs/start": "https://pkg.pr.new/@solidjs/start@dfb2020",
       "solid-js": "1.9.10",
-      "vite-plugin-solid": "2.11.10",
+      "vite-plugin-solid": "2.11.10"
-      "@lydell/node-pty": "1.2.0-beta.10"
     }
   },
   "devDependencies": {
@@ -92,7 +87,6 @@
     "@opencode-ai/plugin": "workspace:*",
     "@opencode-ai/script": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
-    "heap-snapshot-toolkit": "1.1.3",
     "typescript": "catalog:"
   },
   "repository": {
@@ -106,11 +100,9 @@
   },
   "trustedDependencies": [
     "esbuild",
-    "node-pty",
     "protobufjs",
     "tree-sitter",
     "tree-sitter-bash",
-    "tree-sitter-powershell",
     "web-tree-sitter",
     "electron"
   ],
@@ -120,6 +112,8 @@
   },
   "patchedDependencies": {
     "@standard-community/standard-openapi@0.2.9": "patches/@standard-community%2Fstandard-openapi@0.2.9.patch",
+    "@openrouter/ai-sdk-provider@1.5.4": "patches/@openrouter%2Fai-sdk-provider@1.5.4.patch",
+    "@ai-sdk/xai@2.0.51": "patches/@ai-sdk%2Fxai@2.0.51.patch",
     "solid-js@1.9.10": "patches/solid-js@1.9.10.patch"
   }
 }

packages/app/e2e/AGENTS.md

@@ -59,10 +59,8 @@ test("test description", async ({ page, sdk, gotoSession }) => {
 ### Using Fixtures
 
 - `page` - Playwright page
-- `llm` - Mock LLM server for queuing responses (`text`, `tool`, `toolMatch`, `textMatch`, etc.)
+- `sdk` - OpenCode SDK client for API calls
-- `project` - Golden-path project fixture (call `project.open()` first, then use `project.sdk`, `project.prompt(...)`, `project.gotoSession(...)`, `project.trackSession(...)`)
+- `gotoSession(sessionID?)` - Navigate to session
-- `sdk` - OpenCode SDK client for API calls (worker-scoped, shared directory)
-- `gotoSession(sessionID?)` - Navigate to session (worker-scoped, shared directory)
 
 ### Helper Functions
 
@@ -75,9 +73,12 @@ test("test description", async ({ page, sdk, gotoSession }) => {
 - `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`):
@@ -127,9 +128,9 @@ test("test with cleanup", async ({ page, sdk, gotoSession }) => {
 })
 ```
 
-- Prefer the `project` fixture for tests that need a dedicated project with LLM mocking — call `project.open()` then use `project.prompt(...)`, `project.trackSession(...)`, etc.
+- Prefer `withSession(...)` for temp sessions
-- Use `withSession(sdk, title, callback)` for lightweight temp sessions on the shared worker directory
+- In `withProject(...)` tests that create sessions or extra workspaces, call `trackSession(sessionID, directory?)` and `trackDirectory(directory)`
-- Call `project.trackSession(sessionID, directory?)` and `project.trackDirectory(directory)` for any resources created outside the fixture so teardown can clean them up
+- This lets fixture teardown abort, wait for idle, and clean up safely under CI concurrency
 - Avoid calling `sdk.session.delete(...)` directly
 
 ### Timeouts

packages/app/e2e/actions.ts

@@ -7,6 +7,7 @@ import { execSync } from "node:child_process"
 import { terminalAttr, type E2EWindow } from "../src/testing/terminal"
 import { createSdk, modKey, resolveDirectory, serverUrl } from "./utils"
 import {
+  dropdownMenuTriggerSelector,
   dropdownMenuContentSelector,
   projectSwitchSelector,
   projectMenuTriggerSelector,
@@ -174,9 +175,9 @@ export async function runTerminal(page: Page, input: { cmd: string; token: strin
   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()
@@ -205,7 +206,7 @@ export async function closeDialog(page: Page, dialog: Locator) {
   await expect(dialog).toHaveCount(0)
 }
 
-async function isSidebarClosed(page: Page) {
+export async function isSidebarClosed(page: Page) {
   const button = await waitSidebarButton(page, "isSidebarClosed")
   return (await button.getAttribute("aria-expanded")) !== "true"
 }
@@ -236,7 +237,7 @@ async function errorBoundaryText(page: Page) {
   return [title ? "Error boundary" : "", description ?? "", detail ?? ""].filter(Boolean).join("\n")
 }
 
-async function assertHealthy(page: Page, context: string) {
+export async function assertHealthy(page: Page, context: string) {
   const text = await errorBoundaryText(page)
   if (!text) return
   console.log(`[e2e:error-boundary][${context}]\n${text}`)
@@ -311,7 +312,61 @@ export async function openSettings(page: Page) {
   return dialog
 }
 
-export async function createTestProject(input?: { serverUrl?: string }) {
+export async function seedProjects(page: Page, input: { directory: string; extra?: string[] }) {
+  await page.addInitScript(
+    (args: { directory: string; serverUrl: string; extra: string[] }) => {
+      const key = "opencode.global.dat:server"
+      const raw = localStorage.getItem(key)
+      const parsed = (() => {
+        if (!raw) return undefined
+        try {
+          return JSON.parse(raw) as unknown
+        } catch {
+          return undefined
+        }
+      })()
+
+      const store = parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {}
+      const list = Array.isArray(store.list) ? store.list : []
+      const lastProject = store.lastProject && typeof store.lastProject === "object" ? store.lastProject : {}
+      const projects = store.projects && typeof store.projects === "object" ? store.projects : {}
+      const nextProjects = { ...(projects as Record<string, unknown>) }
+
+      const add = (origin: string, directory: string) => {
+        const current = nextProjects[origin]
+        const items = Array.isArray(current) ? current : []
+        const existing = items.filter(
+          (p): p is { worktree: string; expanded?: boolean } =>
+            !!p &&
+            typeof p === "object" &&
+            "worktree" in p &&
+            typeof (p as { worktree?: unknown }).worktree === "string",
+        )
+
+        if (existing.some((p) => p.worktree === directory)) return
+        nextProjects[origin] = [{ worktree: directory, expanded: true }, ...existing]
+      }
+
+      const directories = [args.directory, ...args.extra]
+      for (const directory of directories) {
+        add("local", directory)
+        add(args.serverUrl, directory)
+      }
+
+      localStorage.setItem(
+        key,
+        JSON.stringify({
+          list,
+          projects: nextProjects,
+          lastProject,
+        }),
+      )
+    },
+    { directory: input.directory, serverUrl, extra: input.extra ?? [] },
+  )
+}
+
+export async function createTestProject() {
   const root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-"))
   const id = `e2e-${path.basename(root)}`
 
@@ -320,14 +375,13 @@ export async function createTestProject(input?: { serverUrl?: string }) {
   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 config commit.gpgsign 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, input?.serverUrl)
+  return resolveDirectory(root)
 }
 
 export async function cleanupTestProject(directory: string) {
@@ -376,22 +430,22 @@ export async function waitSlug(page: Page, skip: string[] = []) {
   return next
 }
 
-export async function resolveSlug(slug: string, input?: { serverUrl?: string }) {
+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, input?.serverUrl)
+  const resolved = await resolveDirectory(directory)
   return { directory: resolved, slug: base64Encode(resolved), raw: slug }
 }
 
-export async function waitDir(page: Page, directory: string, input?: { serverUrl?: string }) {
+export async function waitDir(page: Page, directory: string) {
-  const target = await resolveDirectory(directory, input?.serverUrl)
+  const target = await resolveDirectory(directory)
   await expect
     .poll(
       async () => {
         await assertHealthy(page, "waitDir")
         const slug = slugFromUrl(page.url())
         if (!slug) return ""
-        return resolveSlug(slug, input)
+        return resolveSlug(slug)
           .then((item) => item.directory)
           .catch(() => "")
       },
@@ -401,33 +455,22 @@ export async function waitDir(page: Page, directory: string, input?: { serverUrl
   return { directory: target, slug: base64Encode(target) }
 }
 
-export async function waitSession(
+export async function waitSession(page: Page, input: { directory: string; sessionID?: string }) {
-  page: Page,
+  const target = await resolveDirectory(input.directory)
-  input: {
-    directory: string
-    sessionID?: string
-    serverUrl?: string
-    allowAnySession?: boolean
-  },
-) {
-  const target = await resolveDirectory(input.directory, input.serverUrl)
   await expect
     .poll(
       async () => {
         await assertHealthy(page, "waitSession")
         const slug = slugFromUrl(page.url())
         if (!slug) return false
-        const resolved = await resolveSlug(slug, { serverUrl: input.serverUrl }).catch(() => undefined)
+        const resolved = await resolveSlug(slug).catch(() => undefined)
         if (!resolved || resolved.directory !== target) return false
-        const current = sessionIDFromUrl(page.url())
+        if (input.sessionID && sessionIDFromUrl(page.url()) !== input.sessionID) return false
-        if (input.sessionID && current !== input.sessionID) return false
-        if (!input.sessionID && !input.allowAnySession && current) return false
 
         const state = await probeSession(page)
         if (input.sessionID && (!state || state.sessionID !== input.sessionID)) return false
-        if (!input.sessionID && !input.allowAnySession && state?.sessionID) return false
         if (state?.dir) {
-          const dir = await resolveDirectory(state.dir, input.serverUrl).catch(() => state.dir ?? "")
+          const dir = await resolveDirectory(state.dir).catch(() => state.dir ?? "")
           if (dir !== target) return false
         }
 
@@ -443,9 +486,9 @@ export async function waitSession(
   return { directory: target, slug: base64Encode(target) }
 }
 
-export async function waitSessionSaved(directory: string, sessionID: string, timeout = 30_000, serverUrl?: string) {
+export async function waitSessionSaved(directory: string, sessionID: string, timeout = 30_000) {
-  const sdk = createSdk(directory, serverUrl)
+  const sdk = createSdk(directory)
-  const target = await resolveDirectory(directory, serverUrl)
+  const target = await resolveDirectory(directory)
 
   await expect
     .poll(
@@ -455,7 +498,7 @@ export async function waitSessionSaved(directory: string, sessionID: string, tim
           .then((x) => x.data)
           .catch(() => undefined)
         if (!data?.directory) return ""
-        return resolveDirectory(data.directory, serverUrl).catch(() => data.directory)
+        return resolveDirectory(data.directory).catch(() => data.directory)
       },
       { timeout },
     )
@@ -532,15 +575,12 @@ export async function confirmDialog(page: Page, buttonName: string | RegExp) {
 }
 
 export async function openSharePopover(page: Page) {
-  const scroller = page.locator(".scroll-view__viewport").first()
+  const rightSection = page.locator(titlebarRightSelector)
-  await expect(scroller).toBeVisible()
+  const shareButton = rightSection.getByRole("button", { name: "Share" }).first()
-  await expect(scroller.getByRole("heading", { level: 1 }).first()).toBeVisible({ timeout: 30_000 })
+  await expect(shareButton).toBeVisible()
-
-  const menuTrigger = scroller.getByRole("button", { name: /more options/i }).first()
-  await expect(menuTrigger).toBeVisible({ timeout: 30_000 })
 
   const popoverBody = page
-    .locator('[data-component="popover-content"]')
+    .locator(popoverBodySelector)
     .filter({ has: page.getByRole("button", { name: /^(Publish|Unpublish)$/ }) })
     .first()
 
@@ -550,13 +590,16 @@ export async function openSharePopover(page: Page) {
     .catch(() => false)
 
   if (!opened) {
-    const menu = page.locator(dropdownMenuContentSelector).first()
+    await shareButton.click()
-    await menuTrigger.click()
+    await expect(popoverBody).toBeVisible()
-    await clickMenuItem(menu, /share/i)
-    await expect(menu).toHaveCount(0)
-    await expect(popoverBody).toBeVisible({ timeout: 30_000 })
   }
-  return { rightSection: scroller, popoverBody }
+  return { rightSection, popoverBody }
+}
+
+export async function clickPopoverButton(page: Page, buttonName: string | RegExp) {
+  const button = page.getByRole("button").filter({ hasText: buttonName }).first()
+  await expect(button).toBeVisible()
+  await button.click()
 }
 
 export async function clickListItem(
@@ -620,9 +663,8 @@ export async function cleanupSession(input: {
   sessionID: string
   directory?: string
   sdk?: ReturnType<typeof createSdk>
-  serverUrl?: string
 }) {
-  const sdk = input.sdk ?? (input.directory ? createSdk(input.directory, input.serverUrl) : undefined)
+  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)
@@ -724,6 +766,40 @@ export async function seedSessionQuestion(
   return { id: result.id }
 }
 
+export async function seedSessionPermission(
+  sdk: ReturnType<typeof createSdk>,
+  input: {
+    sessionID: string
+    permission: string
+    patterns: string[]
+    description?: string
+  },
+) {
+  const text = [
+    "Your only valid response is one bash tool call.",
+    `Use this JSON input: ${JSON.stringify({
+      command: input.patterns[0] ? `ls ${JSON.stringify(input.patterns[0])}` : "pwd",
+      workdir: "/",
+      description: input.description ?? `seed ${input.permission} permission request`,
+    })}`,
+    "Do not output plain text.",
+  ].join("\n")
+
+  const result = await seed({
+    sdk,
+    sessionID: input.sessionID,
+    prompt: text,
+    timeout: 30_000,
+    probe: async () => {
+      const list = await sdk.permission.list().then((x) => x.data ?? [])
+      return list.find((item) => item.sessionID === input.sessionID)
+    },
+  })
+
+  if (!result) throw new Error("Timed out seeding permission request")
+  return { id: result.id }
+}
+
 export async function seedSessionTask(
   sdk: ReturnType<typeof createSdk>,
   input: {
@@ -782,6 +858,36 @@ export async function seedSessionTask(
   return result
 }
 
+export async function seedSessionTodos(
+  sdk: ReturnType<typeof createSdk>,
+  input: {
+    sessionID: string
+    todos: Array<{ content: string; status: string; priority: string }>
+  },
+) {
+  const text = [
+    "Your only valid response is one todowrite tool call.",
+    `Use this JSON input: ${JSON.stringify({ todos: input.todos })}`,
+    "Do not output plain text.",
+  ].join("\n")
+  const target = JSON.stringify(input.todos)
+
+  const result = await seed({
+    sdk,
+    sessionID: input.sessionID,
+    prompt: text,
+    timeout: 30_000,
+    probe: async () => {
+      const todos = await sdk.session.todo({ sessionID: input.sessionID }).then((x) => x.data ?? [])
+      if (JSON.stringify(todos) !== target) return
+      return true
+    },
+  })
+
+  if (!result) throw new Error("Timed out seeding todos")
+  return true
+}
+
 export async function clearSessionDockSeed(sdk: ReturnType<typeof createSdk>, sessionID: string) {
   const [questions, permissions] = await Promise.all([
     sdk.question.list().then((x) => x.data ?? []),
@@ -871,57 +977,30 @@ export async function openProjectMenu(page: Page, projectSlug: string) {
 }
 
 export async function setWorkspacesEnabled(page: Page, projectSlug: string, enabled: boolean) {
-  const current = () =>
+  const current = await page
-    page
+    .getByRole("button", { name: "New workspace" })
-      .getByRole("button", { name: "New workspace" })
+    .first()
-      .first()
+    .isVisible()
-      .isVisible()
+    .then((x) => x)
-      .then((x) => x)
+    .catch(() => false)
-      .catch(() => false)
 
-  if ((await current()) === enabled) return
+  if (current === enabled) return
-
-  if (enabled) {
-    await page.reload()
-    await openSidebar(page)
-    if ((await 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()
-    await expect(toggle).toBeEnabled({ timeout: 30_000 })
+    return toggle.click({ force: true, timeout })
-    const clicked = await toggle
-      .click({ force: true, timeout })
-      .then(() => true)
-      .catch(() => false)
-    if (clicked) return
-    await toggle.focus()
-    await page.keyboard.press("Enter")
   }
 
-  for (const timeout of [1500, undefined, undefined]) {
+  const flipped = await flip(1500)
-    if ((await current()) === enabled) break
+    .then(() => true)
-    await flip(timeout)
+    .catch(() => false)
-      .then(() => undefined)
-      .catch(() => undefined)
-    const matched = await expect
-      .poll(current, { timeout: 5_000 })
-      .toBe(enabled)
-      .then(() => true)
-      .catch(() => false)
-    if (matched) break
-  }
 
-  if ((await current()) !== enabled) {
+  if (!flipped) await flip()
-    await page.reload()
-    await openSidebar(page)
-  }
 
   const expected = enabled ? "New workspace" : "New session"
-  await expect.poll(current, { timeout: 60_000 }).toBe(enabled)
+  await expect(page.getByRole("button", { name: expected }).first()).toBeVisible()
-  await expect(page.getByRole("button", { name: expected }).first()).toBeVisible({ timeout: 30_000 })
 }
 
 export async function openWorkspaceMenu(page: Page, workspaceSlug: string) {
@@ -937,13 +1016,3 @@ export async function openWorkspaceMenu(page: Page, workspaceSlug: string) {
   await expect(menu).toBeVisible()
   return menu
 }
-
-export async function assistantText(sdk: ReturnType<typeof createSdk>, sessionID: string) {
-  const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
-  return messages
-    .filter((m) => m.info.role === "assistant")
-    .flatMap((m) => m.parts)
-    .filter((p) => p.type === "text")
-    .map((p) => p.text)
-    .join("\n")
-}

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/backend.ts

@@ -1,141 +0,0 @@
-import { spawn } from "node:child_process"
-import fs from "node:fs/promises"
-import net from "node:net"
-import os from "node:os"
-import path from "node:path"
-import { fileURLToPath } from "node:url"
-
-type Handle = {
-  url: string
-  stop: () => Promise<void>
-}
-
-function freePort() {
-  return new Promise<number>((resolve, reject) => {
-    const server = net.createServer()
-    server.once("error", reject)
-    server.listen(0, () => {
-      const address = server.address()
-      if (!address || typeof address === "string") {
-        server.close(() => reject(new Error("Failed to acquire a free port")))
-        return
-      }
-      server.close((err) => {
-        if (err) reject(err)
-        else resolve(address.port)
-      })
-    })
-  })
-}
-
-async function waitForHealth(url: string, probe = "/global/health") {
-  const end = Date.now() + 120_000
-  let last = ""
-  while (Date.now() < end) {
-    try {
-      const res = await fetch(`${url}${probe}`)
-      if (res.ok) return
-      last = `status ${res.status}`
-    } catch (err) {
-      last = err instanceof Error ? err.message : String(err)
-    }
-    await new Promise((resolve) => setTimeout(resolve, 250))
-  }
-  throw new Error(`Timed out waiting for backend health at ${url}${probe}${last ? ` (${last})` : ""}`)
-}
-
-function done(proc: ReturnType<typeof spawn>) {
-  return proc.exitCode !== null || proc.signalCode !== null
-}
-
-async function waitExit(proc: ReturnType<typeof spawn>, timeout = 10_000) {
-  if (done(proc)) return
-  await Promise.race([
-    new Promise<void>((resolve) => proc.once("exit", () => resolve())),
-    new Promise<void>((resolve) => setTimeout(resolve, timeout)),
-  ])
-}
-
-const LOG_CAP = 100
-
-function cap(input: string[]) {
-  if (input.length > LOG_CAP) input.splice(0, input.length - LOG_CAP)
-}
-
-function tail(input: string[]) {
-  return input.slice(-40).join("")
-}
-
-export async function startBackend(label: string, input?: { llmUrl?: string }): Promise<Handle> {
-  const port = await freePort()
-  const sandbox = await fs.mkdtemp(path.join(os.tmpdir(), `opencode-e2e-${label}-`))
-  const appDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
-  const repoDir = path.resolve(appDir, "../..")
-  const opencodeDir = path.join(repoDir, "packages", "opencode")
-  const env = {
-    ...process.env,
-    OPENCODE_DISABLE_LSP_DOWNLOAD: "true",
-    OPENCODE_DISABLE_DEFAULT_PLUGINS: "true",
-    OPENCODE_EXPERIMENTAL_DISABLE_FILEWATCHER: "true",
-    OPENCODE_TEST_HOME: path.join(sandbox, "home"),
-    XDG_DATA_HOME: path.join(sandbox, "share"),
-    XDG_CACHE_HOME: path.join(sandbox, "cache"),
-    XDG_CONFIG_HOME: path.join(sandbox, "config"),
-    XDG_STATE_HOME: path.join(sandbox, "state"),
-    OPENCODE_CLIENT: "app",
-    OPENCODE_STRICT_CONFIG_DEPS: "true",
-    OPENCODE_E2E_LLM_URL: input?.llmUrl,
-  } satisfies Record<string, string | undefined>
-  const out: string[] = []
-  const err: string[] = []
-  const proc = spawn(
-    "bun",
-    ["run", "--conditions=browser", "./src/index.ts", "serve", "--port", String(port), "--hostname", "127.0.0.1"],
-    {
-      cwd: opencodeDir,
-      env,
-      stdio: ["ignore", "pipe", "pipe"],
-    },
-  )
-  proc.stdout?.on("data", (chunk) => {
-    out.push(String(chunk))
-    cap(out)
-  })
-  proc.stderr?.on("data", (chunk) => {
-    err.push(String(chunk))
-    cap(err)
-  })
-
-  const url = `http://127.0.0.1:${port}`
-  try {
-    await waitForHealth(url)
-  } catch (error) {
-    proc.kill("SIGTERM")
-    await fs.rm(sandbox, { recursive: true, force: true }).catch(() => undefined)
-    throw new Error(
-      [
-        `Failed to start isolated e2e backend for ${label}`,
-        error instanceof Error ? error.message : String(error),
-        tail(out),
-        tail(err),
-      ]
-        .filter(Boolean)
-        .join("\n"),
-    )
-  }
-
-  return {
-    url,
-    async stop() {
-      if (!done(proc)) {
-        proc.kill("SIGTERM")
-        await waitExit(proc)
-      }
-      if (!done(proc)) {
-        proc.kill("SIGKILL")
-        await waitExit(proc)
-      }
-      await fs.rm(sandbox, { recursive: true, force: true }).catch(() => undefined)
-    },
-  }
-}

packages/app/e2e/fixtures.ts

@@ -1,251 +1,41 @@
 import { test as base, expect, type Page } from "@playwright/test"
-import { ManagedRuntime } from "effect"
 import type { E2EWindow } from "../src/testing/terminal"
-import type { Item, Reply, Usage } from "../../opencode/test/lib/llm-server"
-import { TestLLMServer } from "../../opencode/test/lib/llm-server"
-import { startBackend } from "./backend"
 import {
   healthPhase,
   cleanupSession,
   cleanupTestProject,
   createTestProject,
   setHealthPhase,
+  seedProjects,
   sessionIDFromUrl,
-  waitSession,
-  waitSessionIdle,
-  waitSessionSaved,
   waitSlug,
+  waitSession,
 } from "./actions"
-import { promptSelector } from "./selectors"
+import { createSdk, dirSlug, getWorktree, sessionPath } from "./utils"
-import { createSdk, dirSlug, getWorktree, serverUrl, sessionPath } from "./utils"
-
-type LLMFixture = {
-  url: string
-  push: (...input: (Item | Reply)[]) => Promise<void>
-  pushMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    ...input: (Item | Reply)[]
-  ) => Promise<void>
-  textMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    value: string,
-    opts?: { usage?: Usage },
-  ) => Promise<void>
-  toolMatch: (
-    match: (hit: { url: URL; body: Record<string, unknown> }) => boolean,
-    name: string,
-    input: unknown,
-  ) => Promise<void>
-  text: (value: string, opts?: { usage?: Usage }) => Promise<void>
-  tool: (name: string, input: unknown) => Promise<void>
-  toolHang: (name: string, input: unknown) => Promise<void>
-  reason: (value: string, opts?: { text?: string; usage?: Usage }) => Promise<void>
-  fail: (message?: unknown) => Promise<void>
-  error: (status: number, body: unknown) => Promise<void>
-  hang: () => Promise<void>
-  hold: (value: string, wait: PromiseLike<unknown>) => Promise<void>
-  hits: () => Promise<Array<{ url: URL; body: Record<string, unknown> }>>
-  calls: () => Promise<number>
-  wait: (count: number) => Promise<void>
-  inputs: () => Promise<Record<string, unknown>[]>
-  pending: () => Promise<number>
-  misses: () => Promise<Array<{ url: URL; body: Record<string, unknown> }>>
-}
-
-type LLMWorker = LLMFixture & {
-  reset: () => Promise<void>
-}
-
-type AssistantFixture = {
-  reply: LLMFixture["text"]
-  tool: LLMFixture["tool"]
-  toolHang: LLMFixture["toolHang"]
-  reason: LLMFixture["reason"]
-  fail: LLMFixture["fail"]
-  error: LLMFixture["error"]
-  hang: LLMFixture["hang"]
-  hold: LLMFixture["hold"]
-  calls: LLMFixture["calls"]
-  pending: LLMFixture["pending"]
-}
 
 export const settingsKey = "settings.v3"
 
-const seedModel = (() => {
-  const [providerID = "opencode", modelID = "big-pickle"] = (
-    process.env.OPENCODE_E2E_MODEL ?? "opencode/big-pickle"
-  ).split("/")
-  return {
-    providerID: providerID || "opencode",
-    modelID: modelID || "big-pickle",
-  }
-})()
-
-function clean(value: string | null) {
-  return (value ?? "").replace(/\u200B/g, "").trim()
-}
-
-async function visit(page: Page, url: string) {
-  let err: unknown
-  for (const _ of [0, 1, 2]) {
-    try {
-      await page.goto(url)
-      return
-    } catch (cause) {
-      err = cause
-      if (!String(cause).includes("ERR_CONNECTION_REFUSED")) throw cause
-      await new Promise((resolve) => setTimeout(resolve, 300))
-    }
-  }
-  throw err
-}
-
-async function promptSend(page: Page) {
-  return page
-    .evaluate(() => {
-      const win = window as E2EWindow
-      const sent = win.__opencode_e2e?.prompt?.sent
-      return {
-        started: sent?.started ?? 0,
-        count: sent?.count ?? 0,
-        sessionID: sent?.sessionID,
-        directory: sent?.directory,
-      }
-    })
-    .catch(() => ({ started: 0, count: 0, sessionID: undefined, directory: undefined }))
-}
-
-type ProjectHandle = {
-  directory: string
-  slug: string
-  gotoSession: (sessionID?: string) => Promise<void>
-  trackSession: (sessionID: string, directory?: string) => void
-  trackDirectory: (directory: string) => void
-  sdk: ReturnType<typeof createSdk>
-}
-
-type ProjectOptions = {
-  extra?: string[]
-  model?: { providerID: string; modelID: string }
-  setup?: (directory: string) => Promise<void>
-  beforeGoto?: (project: { directory: string; sdk: ReturnType<typeof createSdk> }) => Promise<void>
-}
-
-type ProjectFixture = ProjectHandle & {
-  open: (options?: ProjectOptions) => Promise<void>
-  prompt: (text: string) => Promise<string>
-  user: (text: string) => Promise<string>
-  shell: (cmd: string) => Promise<string>
-}
-
 type TestFixtures = {
-  llm: LLMFixture
-  assistant: AssistantFixture
-  project: ProjectFixture
   sdk: ReturnType<typeof createSdk>
   gotoSession: (sessionID?: string) => Promise<void>
+  withProject: <T>(
+    callback: (project: {
+      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>
 }
 
 type WorkerFixtures = {
-  _llm: LLMWorker
-  backend: {
-    url: string
-    sdk: (directory?: string) => ReturnType<typeof createSdk>
-  }
   directory: string
   slug: string
 }
 
 export const test = base.extend<TestFixtures, WorkerFixtures>({
-  _llm: [
-    async ({}, use) => {
-      const rt = ManagedRuntime.make(TestLLMServer.layer)
-      try {
-        const svc = await rt.runPromise(TestLLMServer.asEffect())
-        await use({
-          url: svc.url,
-          push: (...input) => rt.runPromise(svc.push(...input)),
-          pushMatch: (match, ...input) => rt.runPromise(svc.pushMatch(match, ...input)),
-          textMatch: (match, value, opts) => rt.runPromise(svc.textMatch(match, value, opts)),
-          toolMatch: (match, name, input) => rt.runPromise(svc.toolMatch(match, name, input)),
-          text: (value, opts) => rt.runPromise(svc.text(value, opts)),
-          tool: (name, input) => rt.runPromise(svc.tool(name, input)),
-          toolHang: (name, input) => rt.runPromise(svc.toolHang(name, input)),
-          reason: (value, opts) => rt.runPromise(svc.reason(value, opts)),
-          fail: (message) => rt.runPromise(svc.fail(message)),
-          error: (status, body) => rt.runPromise(svc.error(status, body)),
-          hang: () => rt.runPromise(svc.hang),
-          hold: (value, wait) => rt.runPromise(svc.hold(value, wait)),
-          reset: () => rt.runPromise(svc.reset),
-          hits: () => rt.runPromise(svc.hits),
-          calls: () => rt.runPromise(svc.calls),
-          wait: (count) => rt.runPromise(svc.wait(count)),
-          inputs: () => rt.runPromise(svc.inputs),
-          pending: () => rt.runPromise(svc.pending),
-          misses: () => rt.runPromise(svc.misses),
-        })
-      } finally {
-        await rt.dispose()
-      }
-    },
-    { scope: "worker" },
-  ],
-  backend: [
-    async ({ _llm }, use, workerInfo) => {
-      const handle = await startBackend(`w${workerInfo.workerIndex}`, { llmUrl: _llm.url })
-      try {
-        await use({
-          url: handle.url,
-          sdk: (directory?: string) => createSdk(directory, handle.url),
-        })
-      } finally {
-        await handle.stop()
-      }
-    },
-    { scope: "worker" },
-  ],
-  llm: async ({ _llm }, use) => {
-    await _llm.reset()
-    await use({
-      url: _llm.url,
-      push: _llm.push,
-      pushMatch: _llm.pushMatch,
-      textMatch: _llm.textMatch,
-      toolMatch: _llm.toolMatch,
-      text: _llm.text,
-      tool: _llm.tool,
-      toolHang: _llm.toolHang,
-      reason: _llm.reason,
-      fail: _llm.fail,
-      error: _llm.error,
-      hang: _llm.hang,
-      hold: _llm.hold,
-      hits: _llm.hits,
-      calls: _llm.calls,
-      wait: _llm.wait,
-      inputs: _llm.inputs,
-      pending: _llm.pending,
-      misses: _llm.misses,
-    })
-    const pending = await _llm.pending()
-    if (pending > 0) {
-      throw new Error(`TestLLMServer still has ${pending} queued response(s) after the test finished`)
-    }
-  },
-  assistant: async ({ llm }, use) => {
-    await use({
-      reply: llm.text,
-      tool: llm.tool,
-      toolHang: llm.toolHang,
-      reason: llm.reason,
-      fail: llm.fail,
-      error: llm.error,
-      hang: llm.hang,
-      hold: llm.hold,
-      calls: llm.calls,
-      pending: llm.pending,
-    })
-  },
   page: async ({ page }, use) => {
     let boundary: string | undefined
     setHealthPhase(page, "test")
@@ -270,8 +60,9 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
     if (boundary) throw new Error(boundary)
   },
   directory: [
-    async ({ backend }, use) => {
+    async ({}, use) => {
-      await use(await getWorktree(backend.url))
+      const directory = await getWorktree()
+      await use(directory)
     },
     { scope: "worker" },
   ],
@@ -281,324 +72,83 @@ export const test = base.extend<TestFixtures, WorkerFixtures>({
     },
     { scope: "worker" },
   ],
-  sdk: async ({ directory, backend }, use) => {
+  sdk: async ({ directory }, use) => {
-    await use(backend.sdk(directory))
+    await use(createSdk(directory))
   },
-  gotoSession: async ({ page, directory, backend }, use) => {
+  gotoSession: async ({ page, directory }, use) => {
-    await seedStorage(page, { directory, serverUrl: backend.url })
+    await seedStorage(page, { directory })
 
     const gotoSession = async (sessionID?: string) => {
-      await visit(page, sessionPath(directory, sessionID))
+      await page.goto(sessionPath(directory, sessionID))
-      await waitSession(page, {
+      await waitSession(page, { directory, sessionID })
-        directory,
-        sessionID,
-        serverUrl: backend.url,
-        allowAnySession: !sessionID,
-      })
     }
     await use(gotoSession)
   },
-  project: async ({ page, llm, backend }, use) => {
+  withProject: async ({ page }, use) => {
-    const item = makeProject(page, llm, backend)
+    await use(async (callback, options) => {
-    try {
+      const root = await createTestProject()
-      await use(item.project)
+      const sessions = new Map<string, string>()
-    } finally {
+      const dirs = new Set<string>()
-      await item.cleanup()
+      await seedStorage(page, { directory: root, 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)
+      }
+
+      try {
+        await gotoSession()
+        const slug = await waitSlug(page)
+        return await callback({ directory: root, slug, gotoSession, trackSession, trackDirectory })
+      } 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")
+      }
+    })
   },
 })
 
-function makeProject(
+async function seedStorage(page: Page, input: { directory: string; extra?: string[] }) {
-  page: Page,
+  await seedProjects(page, input)
-  llm: LLMFixture,
+  await page.addInitScript(() => {
-  backend: { url: string; sdk: (directory?: string) => ReturnType<typeof createSdk> },
+    const win = window as E2EWindow
-) {
+    win.__opencode_e2e = {
-  let state:
+      ...win.__opencode_e2e,
-    | {
+      model: {
-        directory: string
+        enabled: true,
-        slug: string
+      },
-        sdk: ReturnType<typeof createSdk>
+      prompt: {
-        sessions: Map<string, string>
+        enabled: true,
-        dirs: Set<string>
+      },
-      }
+      terminal: {
-    | undefined
+        enabled: true,
-
+        terminals: {},
-  const need = () => {
+      },
-    if (state) return state
-    throw new Error("project.open() must be called first")
-  }
-
-  const trackSession = (sessionID: string, directory?: string) => {
-    const cur = need()
-    cur.sessions.set(sessionID, directory ?? cur.directory)
-  }
-
-  const trackDirectory = (directory: string) => {
-    const cur = need()
-    if (directory !== cur.directory) cur.dirs.add(directory)
-  }
-
-  const gotoSession = async (sessionID?: string) => {
-    const cur = need()
-    await visit(page, sessionPath(cur.directory, sessionID))
-    await waitSession(page, {
-      directory: cur.directory,
-      sessionID,
-      serverUrl: backend.url,
-      allowAnySession: !sessionID,
-    })
-    const current = sessionIDFromUrl(page.url())
-    if (current) trackSession(current)
-  }
-
-  const open = async (options?: ProjectOptions) => {
-    if (state) return
-    const directory = await createTestProject({ serverUrl: backend.url })
-    const sdk = backend.sdk(directory)
-    await options?.setup?.(directory)
-    await seedStorage(page, {
-      directory,
-      extra: options?.extra,
-      model: options?.model,
-      serverUrl: backend.url,
-    })
-    state = {
-      directory,
-      slug: "",
-      sdk,
-      sessions: new Map(),
-      dirs: new Set(),
     }
-    await options?.beforeGoto?.({ directory, sdk })
+    localStorage.setItem(
-    await gotoSession()
+      "opencode.global.dat:model",
-    need().slug = await waitSlug(page)
+      JSON.stringify({
-  }
+        recent: [{ providerID: "opencode", modelID: "big-pickle" }],
-
+        user: [],
-  const send = async (text: string, input: { noReply: boolean; shell: boolean }) => {
+        variant: {},
-    if (input.noReply) {
+      }),
-      const cur = need()
-      const state = await page.evaluate(() => {
-        const model = (window as E2EWindow).__opencode_e2e?.model?.current
-        if (!model) return null
-        return {
-          dir: model.dir,
-          sessionID: model.sessionID,
-          agent: model.agent,
-          model: model.model ? { providerID: model.model.providerID, modelID: model.model.modelID } : undefined,
-          variant: model.variant ?? undefined,
-        }
-      })
-      const dir = state?.dir ?? cur.directory
-      const sdk = backend.sdk(dir)
-      const sessionID = state?.sessionID
-        ? state.sessionID
-        : await sdk.session.create({ directory: dir, title: "E2E Session" }).then((res) => {
-            if (!res.data?.id) throw new Error("Failed to create no-reply session")
-            return res.data.id
-          })
-      await sdk.session.prompt({
-        sessionID,
-        agent: state?.agent,
-        model: state?.model,
-        variant: state?.variant,
-        noReply: true,
-        parts: [{ type: "text", text }],
-      })
-      await visit(page, sessionPath(dir, sessionID))
-      const active = await waitSession(page, {
-        directory: dir,
-        sessionID,
-        serverUrl: backend.url,
-      })
-      trackSession(sessionID, active.directory)
-      await waitSessionSaved(active.directory, sessionID, 90_000, backend.url)
-      return sessionID
-    }
-
-    const prev = await promptSend(page)
-    if (!input.noReply && !input.shell && (await llm.pending()) === 0) {
-      await llm.text("ok")
-    }
-
-    const prompt = page.locator(promptSelector).first()
-    const submit = async () => {
-      await expect(prompt).toBeVisible()
-      await prompt.click()
-      if (input.shell) {
-        await page.keyboard.type("!")
-        await expect(prompt).toHaveAttribute("aria-label", /enter shell command/i)
-      }
-      await page.keyboard.type(text)
-      await expect.poll(async () => clean(await prompt.textContent())).toBe(text)
-      await page.keyboard.press("Enter")
-      const started = await expect
-        .poll(async () => (await promptSend(page)).started, { timeout: 5_000 })
-        .toBeGreaterThan(prev.started)
-        .then(() => true)
-        .catch(() => false)
-      if (started) return
-      const send = page.getByRole("button", { name: "Send" }).first()
-      const enabled = await send
-        .isEnabled()
-        .then((x) => x)
-        .catch(() => false)
-      if (enabled) {
-        await send.click()
-      } else {
-        await prompt.click()
-        await page.keyboard.press("Enter")
-      }
-      await expect.poll(async () => (await promptSend(page)).started, { timeout: 5_000 }).toBeGreaterThan(prev.started)
-    }
-
-    await submit()
-
-    let next: { sessionID: string; directory: string } | undefined
-    await expect
-      .poll(
-        async () => {
-          const sent = await promptSend(page)
-          if (sent.count <= prev.count) return ""
-          if (!sent.sessionID || !sent.directory) return ""
-          next = { sessionID: sent.sessionID, directory: sent.directory }
-          return sent.sessionID
-        },
-        { timeout: 90_000 },
-      )
-      .not.toBe("")
-
-    if (!next) throw new Error("Failed to observe prompt submission in e2e prompt probe")
-    const active = await waitSession(page, {
-      directory: next.directory,
-      sessionID: next.sessionID,
-      serverUrl: backend.url,
-    })
-    trackSession(next.sessionID, active.directory)
-    if (!input.shell) {
-      await waitSessionSaved(active.directory, next.sessionID, 90_000, backend.url)
-    }
-    await waitSessionIdle(backend.sdk(active.directory), next.sessionID, 90_000).catch(() => undefined)
-    return next.sessionID
-  }
-
-  const prompt = async (text: string) => {
-    return send(text, { noReply: false, shell: false })
-  }
-
-  const user = async (text: string) => {
-    return send(text, { noReply: true, shell: false })
-  }
-
-  const shell = async (cmd: string) => {
-    return send(cmd, { noReply: false, shell: true })
-  }
-
-  const cleanup = async () => {
-    const cur = state
-    if (!cur) return
-    setHealthPhase(page, "cleanup")
-    await Promise.allSettled(
-      Array.from(cur.sessions, ([sessionID, directory]) =>
-        cleanupSession({ sessionID, directory, serverUrl: backend.url }),
-      ),
     )
-    await Promise.allSettled(Array.from(cur.dirs, (directory) => cleanupTestProject(directory)))
+  })
-    await cleanupTestProject(cur.directory)
-    state = undefined
-    setHealthPhase(page, "test")
-  }
-
-  return {
-    project: {
-      open,
-      prompt,
-      user,
-      shell,
-      gotoSession,
-      trackSession,
-      trackDirectory,
-      get directory() {
-        return need().directory
-      },
-      get slug() {
-        return need().slug
-      },
-      get sdk() {
-        return need().sdk
-      },
-    },
-    cleanup,
-  }
-}
-
-async function seedStorage(
-  page: Page,
-  input: {
-    directory: string
-    extra?: string[]
-    model?: { providerID: string; modelID: string }
-    serverUrl?: string
-  },
-) {
-  const origin = input.serverUrl ?? serverUrl
-  await page.addInitScript(
-    (args: {
-      directory: string
-      serverUrl: string
-      extra: string[]
-      model: { providerID: string; modelID: string }
-    }) => {
-      const key = "opencode.global.dat:server"
-      const raw = localStorage.getItem(key)
-      const parsed = (() => {
-        if (!raw) return undefined
-        try {
-          return JSON.parse(raw) as unknown
-        } catch {
-          return undefined
-        }
-      })()
-
-      const store = parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {}
-      const list = Array.isArray(store.list) ? store.list : []
-      const lastProject = store.lastProject && typeof store.lastProject === "object" ? store.lastProject : {}
-      const projects = store.projects && typeof store.projects === "object" ? store.projects : {}
-      const next = { ...(projects as Record<string, unknown>) }
-      const nextList = list.includes(args.serverUrl) ? list : [args.serverUrl, ...list]
-
-      const add = (origin: string, directory: string) => {
-        const current = next[origin]
-        const items = Array.isArray(current) ? current : []
-        const existing = items.filter(
-          (p): p is { worktree: string; expanded?: boolean } =>
-            !!p &&
-            typeof p === "object" &&
-            "worktree" in p &&
-            typeof (p as { worktree?: unknown }).worktree === "string",
-        )
-        if (existing.some((p) => p.worktree === directory)) return
-        next[origin] = [{ worktree: directory, expanded: true }, ...existing]
-      }
-
-      for (const directory of [args.directory, ...args.extra]) {
-        add("local", directory)
-        add(args.serverUrl, directory)
-      }
-
-      localStorage.setItem(key, JSON.stringify({ list: nextList, projects: next, lastProject }))
-      localStorage.setItem("opencode.settings.dat:defaultServerUrl", args.serverUrl)
-
-      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({ recent: [args.model], user: [], variant: {} }))
-    },
-    { directory: input.directory, serverUrl: origin, extra: input.extra ?? [], model: input.model ?? seedModel },
-  )
 }
 
 export { expect }

packages/app/e2e/models/model-picker.spec.ts

@@ -2,7 +2,7 @@ import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
 import { clickListItem } from "../actions"
 
-test.fixme("smoke model selection updates prompt footer", async ({ page, gotoSession }) => {
+test("smoke model selection updates prompt footer", async ({ page, gotoSession }) => {
   await gotoSession()
 
   await page.locator(promptSelector).click()

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

@@ -1,49 +1,43 @@
 import { test, expect } from "../fixtures"
 import { clickMenuItem, openProjectMenu, openSidebar } from "../actions"
 
-test("dialog edit project updates name and startup script", async ({ page, project }) => {
+test("dialog edit project updates name and startup script", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
-  await project.open()
+  await withProject(async ({ slug }) => {
-  await openSidebar(page)
+    await openSidebar(page)
 
-  const open = async () => {
+    const open = async () => {
-    const menu = await openProjectMenu(page, project.slug)
+      const menu = await openProjectMenu(page, slug)
-    await clickMenuItem(menu, /^Edit$/i, { force: true })
+      await clickMenuItem(menu, /^Edit$/i, { force: true })
 
-    const dialog = page.getByRole("dialog")
+      const dialog = page.getByRole("dialog")
-    await expect(dialog).toBeVisible()
+      await expect(dialog).toBeVisible()
-    await expect(dialog.getByRole("heading", { level: 2 })).toHaveText("Edit project")
+      await expect(dialog.getByRole("heading", { level: 2 })).toHaveText("Edit project")
-    return dialog
+      return dialog
-  }
+    }
 
-  const name = `e2e project ${Date.now()}`
+    const name = `e2e project ${Date.now()}`
-  const startup = `echo e2e_${Date.now()}`
+    const startup = `echo e2e_${Date.now()}`
 
-  const dialog = await open()
+    const dialog = await open()
 
-  const nameInput = dialog.getByLabel("Name")
+    const nameInput = dialog.getByLabel("Name")
-  await nameInput.fill(name)
+    await nameInput.fill(name)
 
-  const startupInput = dialog.getByLabel("Workspace startup script")
+    const startupInput = dialog.getByLabel("Workspace startup script")
-  await startupInput.fill(startup)
+    await startupInput.fill(startup)
 
-  await dialog.getByRole("button", { name: "Save" }).click()
+    await dialog.getByRole("button", { name: "Save" }).click()
-  await expect(dialog).toHaveCount(0)
+    await expect(dialog).toHaveCount(0)
 
-  await expect
+    const header = page.locator(".group\\/project").first()
-    .poll(
+    await expect(header).toContainText(name)
-      async () => {
+
-        await page.reload()
+    const reopened = await open()
-        await openSidebar(page)
+    await expect(reopened.getByLabel("Name")).toHaveValue(name)
-        const reopened = await open()
+    await expect(reopened.getByLabel("Workspace startup script")).toHaveValue(startup)
-        const value = await reopened.getByLabel("Name").inputValue()
+    await reopened.getByRole("button", { name: "Cancel" }).click()
-        const next = await reopened.getByLabel("Workspace startup script").inputValue()
+    await expect(reopened).toHaveCount(0)
-        await reopened.getByRole("button", { name: "Cancel" }).click()
+  })
-        await expect(reopened).toHaveCount(0)
-        return `${value}\n${next}`
-      },
-      { timeout: 30_000 },
-    )
-    .toBe(`${name}\n${startup}`)
 })

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

@@ -3,46 +3,51 @@ import { createTestProject, cleanupTestProject, openSidebar, clickMenuItem, open
 import { projectSwitchSelector } from "../selectors"
 import { dirSlug } from "../utils"
 
-test("closing active project navigates to another open project", async ({ page, project }) => {
+test("closing active project navigates to another open project", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
   const other = await createTestProject()
   const otherSlug = dirSlug(other)
 
   try {
-    await project.open({ extra: [other] })
+    await withProject(
-    await openSidebar(page)
+      async ({ slug }) => {
+        await openSidebar(page)
 
-    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+        const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
-    await expect(otherButton).toBeVisible()
+        await expect(otherButton).toBeVisible()
-    await otherButton.click()
+        await otherButton.click()
 
-    await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
+        await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
 
-    const menu = await openProjectMenu(page, otherSlug)
+        const menu = await openProjectMenu(page, otherSlug)
-    await clickMenuItem(menu, /^Close$/i, { force: true })
 
-    await expect
+        await clickMenuItem(menu, /^Close$/i, { force: true })
-      .poll(
-        () => {
-          const pathname = new URL(page.url()).pathname
-          if (new RegExp(`^/${project.slug}/session(?:/[^/]+)?/?$`).test(pathname)) return "project"
-          if (pathname === "/") return "home"
-          return ""
-        },
-        { timeout: 15_000 },
-      )
-      .toMatch(/^(project|home)$/)
 
-    await expect(page).not.toHaveURL(new RegExp(`/${otherSlug}/session(?:[/?#]|$)`))
+        await expect
-    await expect
+          .poll(
-      .poll(
+            () => {
-        async () => {
+              const pathname = new URL(page.url()).pathname
-          return await page.locator(projectSwitchSelector(otherSlug)).count()
+              if (new RegExp(`^/${slug}/session(?:/[^/]+)?/?$`).test(pathname)) return "project"
-        },
+              if (pathname === "/") return "home"
-        { timeout: 15_000 },
+              return ""
-      )
+            },
-      .toBe(0)
+            { timeout: 15_000 },
+          )
+          .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)
+      },
+      { extra: [other] },
+    )
   } finally {
     await cleanupTestProject(other)
   }

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

@@ -5,89 +5,111 @@ import {
   createTestProject,
   cleanupTestProject,
   openSidebar,
+  sessionIDFromUrl,
   setWorkspacesEnabled,
   waitSession,
+  waitSessionSaved,
   waitSlug,
 } from "../actions"
-import { projectSwitchSelector, workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
+import { projectSwitchSelector, promptSelector, workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
 import { dirSlug, resolveDirectory } from "../utils"
 
-test("can switch between projects from sidebar", async ({ page, project }) => {
+test("can switch between projects from sidebar", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
   const other = await createTestProject()
   const otherSlug = dirSlug(other)
 
   try {
-    await project.open({ extra: [other] })
+    await withProject(
-    await defocus(page)
+      async ({ directory }) => {
+        await defocus(page)
 
-    const currentSlug = dirSlug(project.directory)
+        const currentSlug = dirSlug(directory)
-    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+        const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
-    await expect(otherButton).toBeVisible()
+        await expect(otherButton).toBeVisible()
-    await otherButton.click()
+        await otherButton.click()
 
-    await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
+        await expect(page).toHaveURL(new RegExp(`/${otherSlug}/session`))
 
-    const currentButton = page.locator(projectSwitchSelector(currentSlug)).first()
+        const currentButton = page.locator(projectSwitchSelector(currentSlug)).first()
-    await expect(currentButton).toBeVisible()
+        await expect(currentButton).toBeVisible()
-    await currentButton.click()
+        await currentButton.click()
 
-    await expect(page).toHaveURL(new RegExp(`/${currentSlug}/session`))
+        await expect(page).toHaveURL(new RegExp(`/${currentSlug}/session`))
+      },
+      { extra: [other] },
+    )
   } finally {
     await cleanupTestProject(other)
   }
 })
 
-test("switching back to a project opens the latest workspace session", async ({ page, project }) => {
+test("switching back to a project opens the latest workspace session", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
   const other = await createTestProject()
   const otherSlug = dirSlug(other)
   try {
-    await project.open({ extra: [other] })
+    await withProject(
-    await defocus(page)
+      async ({ directory, slug, trackSession, trackDirectory }) => {
-    await setWorkspacesEnabled(page, project.slug, true)
+        await defocus(page)
-    await openSidebar(page)
+        await setWorkspacesEnabled(page, slug, true)
-    await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
+        await openSidebar(page)
+        await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
 
-    await page.getByRole("button", { name: "New workspace" }).first().click()
+        await page.getByRole("button", { name: "New workspace" }).first().click()
 
-    const raw = await waitSlug(page, [project.slug])
+        const raw = await waitSlug(page, [slug])
-    const dir = base64Decode(raw)
+        const dir = base64Decode(raw)
-    if (!dir) throw new Error(`Failed to decode workspace slug: ${raw}`)
+        if (!dir) throw new Error(`Failed to decode workspace slug: ${raw}`)
-    const space = await resolveDirectory(dir)
+        const space = await resolveDirectory(dir)
-    const next = dirSlug(space)
+        const next = dirSlug(space)
-    project.trackDirectory(space)
+        trackDirectory(space)
-    await openSidebar(page)
+        await openSidebar(page)
 
-    const item = page.locator(`${workspaceItemSelector(next)}, ${workspaceItemSelector(raw)}`).first()
+        const item = page.locator(`${workspaceItemSelector(next)}, ${workspaceItemSelector(raw)}`).first()
-    await expect(item).toBeVisible()
+        await expect(item).toBeVisible()
-    await item.hover()
+        await item.hover()
 
-    const btn = page.locator(`${workspaceNewSessionSelector(next)}, ${workspaceNewSessionSelector(raw)}`).first()
+        const btn = page.locator(`${workspaceNewSessionSelector(next)}, ${workspaceNewSessionSelector(raw)}`).first()
-    await expect(btn).toBeVisible()
+        await expect(btn).toBeVisible()
-    await btn.click({ force: true })
+        await btn.click({ force: true })
 
-    await waitSession(page, { directory: space })
+        await waitSession(page, { directory: space })
 
-    const created = await project.user("test")
+        // Create a session by sending a prompt
+        const prompt = page.locator(promptSelector)
+        await expect(prompt).toBeVisible()
+        await prompt.fill("test")
+        await page.keyboard.press("Enter")
 
-    await expect(page).toHaveURL(new RegExp(`/${next}/session/${created}(?:[/?#]|$)`))
+        // Wait for the URL to update with the new session ID
+        await expect.poll(() => sessionIDFromUrl(page.url()) ?? "", { timeout: 15_000 }).not.toBe("")
 
-    await openSidebar(page)
+        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)
 
-    const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
+        await expect(page).toHaveURL(new RegExp(`/${next}/session/${created}(?:[/?#]|$)`))
-    await expect(otherButton).toBeVisible()
-    await otherButton.click({ force: true })
-    await waitSession(page, { directory: other })
 
-    const rootButton = page.locator(projectSwitchSelector(project.slug)).first()
+        await openSidebar(page)
-    await expect(rootButton).toBeVisible()
-    await rootButton.click({ force: true })
 
-    await waitSession(page, { directory: space, sessionID: created })
+        const otherButton = page.locator(projectSwitchSelector(otherSlug)).first()
-    await expect(page).toHaveURL(new RegExp(`/session/${created}(?:[/?#]|$)`))
+        await expect(otherButton).toBeVisible()
+        await otherButton.click({ force: true })
+        await waitSession(page, { directory: other })
+
+        const rootButton = page.locator(projectSwitchSelector(slug)).first()
+        await expect(rootButton).toBeVisible()
+        await rootButton.click({ force: true })
+
+        await waitSession(page, { directory: space, sessionID: created })
+        await expect(page).toHaveURL(new RegExp(`/session/${created}(?:[/?#]|$)`))
+      },
+      { extra: [other] },
+    )
   } finally {
     await cleanupTestProject(other)
   }

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

@@ -7,9 +7,11 @@ import {
   setWorkspacesEnabled,
   waitDir,
   waitSession,
+  waitSessionSaved,
   waitSlug,
 } from "../actions"
-import { workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
+import { promptSelector, workspaceItemSelector, workspaceNewSessionSelector } from "../selectors"
+import { createSdk } from "../utils"
 
 function item(space: { slug: string; raw: string }) {
   return `${workspaceItemSelector(space.slug)}, ${workspaceItemSelector(space.raw)}`
@@ -48,31 +50,45 @@ async function openWorkspaceNewSession(page: Page, space: { slug: string; raw: s
 }
 
 async function createSessionFromWorkspace(
-  project: Parameters<typeof test>[0]["project"],
   page: Page,
   space: { slug: string; raw: string; directory: string },
   text: string,
 ) {
   await openWorkspaceNewSession(page, space)
-  return project.user(text)
+
+  const prompt = page.locator(promptSelector)
+  await expect(prompt).toBeVisible()
+  await prompt.fill(text)
+  await page.keyboard.press("Enter")
+
+  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)
+  return sessionID
 }
 
-test("new sessions from sidebar workspace actions stay in selected workspace", async ({ page, project }) => {
+test("new sessions from sidebar workspace actions stay in selected workspace", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
-  await project.open()
+  await withProject(async ({ slug: root, trackDirectory, trackSession }) => {
-  await openSidebar(page)
+    await openSidebar(page)
-  await setWorkspacesEnabled(page, project.slug, true)
+    await setWorkspacesEnabled(page, root, true)
 
-  const first = await createWorkspace(page, project.slug, [])
+    const first = await createWorkspace(page, root, [])
-  project.trackDirectory(first.directory)
+    trackDirectory(first.directory)
-  await waitWorkspaceReady(page, first)
+    await waitWorkspaceReady(page, first)
 
-  const second = await createWorkspace(page, project.slug, [first.slug])
+    const second = await createWorkspace(page, root, [first.slug])
-  project.trackDirectory(second.directory)
+    trackDirectory(second.directory)
-  await waitWorkspaceReady(page, second)
+    await waitWorkspaceReady(page, second)
 
-  await createSessionFromWorkspace(project, page, first, `workspace one ${Date.now()}`)
+    trackSession(await createSessionFromWorkspace(page, first, `workspace one ${Date.now()}`), first.directory)
-  await createSessionFromWorkspace(project, page, second, `workspace two ${Date.now()}`)
+    trackSession(await createSessionFromWorkspace(page, second, `workspace two ${Date.now()}`), second.directory)
-  await createSessionFromWorkspace(project, page, first, `workspace one again ${Date.now()}`)
+    trackSession(await createSessionFromWorkspace(page, first, `workspace one again ${Date.now()}`), first.directory)
+  })
 })

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

@@ -19,10 +19,10 @@ import {
   waitDir,
   waitSlug,
 } from "../actions"
-import { inlineInputSelector, workspaceItemSelector } from "../selectors"
+import { dropdownMenuContentSelector, inlineInputSelector, workspaceItemSelector } from "../selectors"
-import { dirSlug } from "../utils"
+import { createSdk, dirSlug } from "../utils"
 
-async function setupWorkspaceTest(page: Page, project: { slug: string; trackDirectory: (directory: string) => void }) {
+async function setupWorkspaceTest(page: Page, project: { slug: string }) {
   const rootSlug = project.slug
   await openSidebar(page)
 
@@ -31,7 +31,6 @@ async function setupWorkspaceTest(page: Page, project: { slug: string; trackDire
   await page.getByRole("button", { name: "New workspace" }).first().click()
   const next = await resolveSlug(await waitSlug(page, [rootSlug]))
   await waitDir(page, next.directory)
-  project.trackDirectory(next.directory)
 
   await openSidebar(page)
 
@@ -53,192 +52,44 @@ async function setupWorkspaceTest(page: Page, project: { slug: string; trackDire
   return { rootSlug, slug: next.slug, directory: next.directory }
 }
 
-test("can enable and disable workspaces from project menu", async ({ page, project }) => {
+test("can enable and disable workspaces from project menu", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
 
-  await openSidebar(page)
+  await withProject(async ({ slug }) => {
+    await openSidebar(page)
 
-  await expect(page.getByRole("button", { name: "New session" }).first()).toBeVisible()
+    await expect(page.getByRole("button", { name: "New session" }).first()).toBeVisible()
-  await expect(page.getByRole("button", { name: "New workspace" })).toHaveCount(0)
+    await expect(page.getByRole("button", { name: "New workspace" })).toHaveCount(0)
 
-  await setWorkspacesEnabled(page, project.slug, true)
+    await setWorkspacesEnabled(page, slug, true)
-  await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
+    await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
-  await expect(page.locator(workspaceItemSelector(project.slug)).first()).toBeVisible()
+    await expect(page.locator(workspaceItemSelector(slug)).first()).toBeVisible()
 
-  await setWorkspacesEnabled(page, project.slug, false)
+    await setWorkspacesEnabled(page, slug, false)
-  await expect(page.getByRole("button", { name: "New session" }).first()).toBeVisible()
+    await expect(page.getByRole("button", { name: "New session" }).first()).toBeVisible()
-  await expect(page.locator(workspaceItemSelector(project.slug))).toHaveCount(0)
+    await expect(page.locator(workspaceItemSelector(slug))).toHaveCount(0)
+  })
 })
 
-test("can create a workspace", async ({ page, project }) => {
+test("can create a workspace", async ({ page, withProject }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
-
-  await openSidebar(page)
-  await setWorkspacesEnabled(page, project.slug, true)
-
-  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, [project.slug]))
-  await waitDir(page, next.directory)
-  project.trackDirectory(next.directory)
-
-  await openSidebar(page)
-
-  await expect
-    .poll(
-      async () => {
-        const item = page.locator(workspaceItemSelector(next.slug)).first()
-        try {
-          await item.hover({ timeout: 500 })
-          return true
-        } catch {
-          return false
-        }
-      },
-      { timeout: 60_000 },
-    )
-    .toBe(true)
-
-  await expect(page.locator(workspaceItemSelector(next.slug)).first()).toBeVisible()
-})
-
-test("non-git projects keep workspace mode disabled", async ({ page, project }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
 
-  const nonGit = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-nongit-"))
+  await withProject(async ({ slug }) => {
-  const nonGitSlug = dirSlug(nonGit)
+    await openSidebar(page)
+    await setWorkspacesEnabled(page, slug, true)
 
-  await fs.writeFile(path.join(nonGit, "README.md"), "# e2e nongit\n")
+    await expect(page.getByRole("button", { name: "New workspace" }).first()).toBeVisible()
 
-  try {
+    await page.getByRole("button", { name: "New workspace" }).first().click()
-    await project.open({ extra: [nonGit] })
+    const next = await resolveSlug(await waitSlug(page, [slug]))
-    await page.goto(`/${nonGitSlug}/session`)
+    await waitDir(page, next.directory)
-
-    await expect.poll(() => slugFromUrl(page.url()), { timeout: 30_000 }).not.toBe("")
-
-    const activeDir = await resolveSlug(slugFromUrl(page.url())).then((item) => item.directory)
-    expect(path.basename(activeDir)).toContain("opencode-e2e-project-nongit-")
 
     await openSidebar(page)
-    await expect(page.getByRole("button", { name: "New workspace" })).toHaveCount(0)
-    await expect(page.getByRole("button", { name: "Create Git repository" })).toBeVisible()
-  } finally {
-    await cleanupTestProject(nonGit)
-  }
-})
 
-test("can rename a workspace", async ({ page, project }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
-
-  const { slug } = await setupWorkspaceTest(page, project)
-
-  const rename = `e2e workspace ${Date.now()}`
-  const menu = await openWorkspaceMenu(page, slug)
-  await clickMenuItem(menu, /^Rename$/i, { force: true })
-
-  await expect(menu).toHaveCount(0)
-
-  const item = page.locator(workspaceItemSelector(slug)).first()
-  await expect(item).toBeVisible()
-  const input = item.locator(inlineInputSelector).first()
-  const shown = await input
-    .isVisible()
-    .then((x) => x)
-    .catch(() => false)
-  if (!shown) {
-    const retry = await openWorkspaceMenu(page, slug)
-    await clickMenuItem(retry, /^Rename$/i, { force: true })
-    await expect(retry).toHaveCount(0)
-  }
-  await expect(input).toBeVisible()
-  await input.fill(rename)
-  await input.press("Enter")
-  await expect(item).toContainText(rename)
-})
-
-test("can reset a workspace", async ({ page, project }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
-
-  const { slug, directory: createdDir } = await setupWorkspaceTest(page, project)
-
-  const readme = path.join(createdDir, "README.md")
-  const extra = path.join(createdDir, `e2e_reset_${Date.now()}.txt`)
-  const original = await fs.readFile(readme, "utf8")
-  const dirty = `${original.trimEnd()}\n\nchange_${Date.now()}\n`
-  await fs.writeFile(readme, dirty, "utf8")
-  await fs.writeFile(extra, `created_${Date.now()}\n`, "utf8")
-
-  await expect
-    .poll(async () => {
-      return await fs
-        .stat(extra)
-        .then(() => true)
-        .catch(() => false)
-    })
-    .toBe(true)
-
-  await expect
-    .poll(async () => {
-      const files = await project.sdk.file
-        .status({ directory: createdDir })
-        .then((r) => r.data ?? [])
-        .catch(() => [])
-      return files.length
-    })
-    .toBeGreaterThan(0)
-
-  const menu = await openWorkspaceMenu(page, slug)
-  await clickMenuItem(menu, /^Reset$/i, { force: true })
-  await confirmDialog(page, /^Reset workspace$/i)
-
-  await expect
-    .poll(
-      async () => {
-        const files = await project.sdk.file
-          .status({ directory: createdDir })
-          .then((r) => r.data ?? [])
-          .catch(() => [])
-        return files.length
-      },
-      { timeout: 120_000 },
-    )
-    .toBe(0)
-
-  await expect.poll(() => fs.readFile(readme, "utf8"), { timeout: 120_000 }).toBe(original)
-
-  await expect
-    .poll(async () => {
-      return await fs
-        .stat(extra)
-        .then(() => true)
-        .catch(() => false)
-    })
-    .toBe(false)
-})
-
-test("can reorder workspaces by drag and drop", async ({ page, project }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
-  const rootSlug = project.slug
-
-  const listSlugs = async () => {
-    const nodes = page.locator('[data-component="sidebar-nav-desktop"] [data-component="workspace-item"]')
-    const slugs = await nodes.evaluateAll((els) => {
-      return els.map((el) => el.getAttribute("data-workspace") ?? "").filter((x) => x.length > 0)
-    })
-    return slugs
-  }
-
-  const waitReady = async (slug: string) => {
     await expect
       .poll(
         async () => {
-          const item = page.locator(workspaceItemSelector(slug)).first()
+          const item = page.locator(workspaceItemSelector(next.slug)).first()
           try {
             await item.hover({ timeout: 500 })
             return true
@@ -249,120 +100,276 @@ test("can reorder workspaces by drag and drop", async ({ page, project }) => {
         { timeout: 60_000 },
       )
       .toBe(true)
+
+    await expect(page.locator(workspaceItemSelector(next.slug)).first()).toBeVisible()
+
+    await cleanupTestProject(next.directory)
+  })
+})
+
+test("non-git projects keep workspace mode disabled", async ({ page, withProject }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  const nonGit = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-e2e-project-nongit-"))
+  const nonGitSlug = dirSlug(nonGit)
+
+  await fs.writeFile(path.join(nonGit, "README.md"), "# e2e nongit\n")
+
+  try {
+    await withProject(async () => {
+      await page.goto(`/${nonGitSlug}/session`)
+
+      await expect.poll(() => slugFromUrl(page.url()), { timeout: 30_000 }).not.toBe("")
+
+      const activeDir = await resolveSlug(slugFromUrl(page.url())).then((item) => item.directory)
+      expect(path.basename(activeDir)).toContain("opencode-e2e-project-nongit-")
+
+      await openSidebar(page)
+      await expect(page.getByRole("button", { name: "New workspace" })).toHaveCount(0)
+
+      const trigger = page.locator('[data-action="project-menu"]').first()
+      const hasMenu = await trigger
+        .isVisible()
+        .then((x) => x)
+        .catch(() => false)
+      if (!hasMenu) return
+
+      await trigger.click({ force: true })
+
+      const menu = page.locator(dropdownMenuContentSelector).first()
+      await expect(menu).toBeVisible()
+
+      const toggle = menu.locator('[data-action="project-workspaces-toggle"]').first()
+
+      await expect(toggle).toBeVisible()
+      await expect(toggle).toBeDisabled()
+      await expect(menu.getByRole("menuitem", { name: "New workspace" })).toHaveCount(0)
+    })
+  } finally {
+    await cleanupTestProject(nonGit)
   }
+})
 
-  const drag = async (from: string, to: string) => {
+test("can rename a workspace", async ({ page, withProject }) => {
-    const src = page.locator(workspaceItemSelector(from)).first()
+  await page.setViewportSize({ width: 1400, height: 800 })
-    const dst = page.locator(workspaceItemSelector(to)).first()
 
-    const a = await src.boundingBox()
+  await withProject(async (project) => {
-    const b = await dst.boundingBox()
+    const { slug } = await setupWorkspaceTest(page, project)
-    if (!a || !b) throw new Error("Failed to resolve workspace drag bounds")
 
-    await page.mouse.move(a.x + a.width / 2, a.y + a.height / 2)
+    const rename = `e2e workspace ${Date.now()}`
-    await page.mouse.down()
+    const menu = await openWorkspaceMenu(page, slug)
-    await page.mouse.move(b.x + b.width / 2, b.y + b.height / 2, { steps: 12 })
+    await clickMenuItem(menu, /^Rename$/i, { force: true })
-    await page.mouse.up()
-  }
 
-  await openSidebar(page)
+    await expect(menu).toHaveCount(0)
 
-  await setWorkspacesEnabled(page, rootSlug, true)
+    const item = page.locator(workspaceItemSelector(slug)).first()
+    await expect(item).toBeVisible()
+    const input = item.locator(inlineInputSelector).first()
+    await expect(input).toBeVisible()
+    await input.fill(rename)
+    await input.press("Enter")
+    await expect(item).toContainText(rename)
+  })
+})
 
-  const workspaces = [] as { directory: string; slug: string }[]
+test("can reset a workspace", async ({ page, sdk, withProject }) => {
-  for (const _ of [0, 1]) {
+  await page.setViewportSize({ width: 1400, height: 800 })
-    const prev = slugFromUrl(page.url())
+
-    await page.getByRole("button", { name: "New workspace" }).first().click()
+  await withProject(async (project) => {
-    const next = await resolveSlug(await waitSlug(page, [rootSlug, prev]))
+    const { slug, directory: createdDir } = await setupWorkspaceTest(page, project)
-    await waitDir(page, next.directory)
+
-    project.trackDirectory(next.directory)
+    const readme = path.join(createdDir, "README.md")
-    workspaces.push(next)
+    const extra = path.join(createdDir, `e2e_reset_${Date.now()}.txt`)
+    const original = await fs.readFile(readme, "utf8")
+    const dirty = `${original.trimEnd()}\n\nchange_${Date.now()}\n`
+    await fs.writeFile(readme, dirty, "utf8")
+    await fs.writeFile(extra, `created_${Date.now()}\n`, "utf8")
+
+    await expect
+      .poll(async () => {
+        return await fs
+          .stat(extra)
+          .then(() => true)
+          .catch(() => false)
+      })
+      .toBe(true)
+
+    await expect
+      .poll(async () => {
+        const files = await sdk.file
+          .status({ directory: createdDir })
+          .then((r) => r.data ?? [])
+          .catch(() => [])
+        return files.length
+      })
+      .toBeGreaterThan(0)
+
+    const menu = await openWorkspaceMenu(page, slug)
+    await clickMenuItem(menu, /^Reset$/i, { force: true })
+    await confirmDialog(page, /^Reset workspace$/i)
+
+    await expect
+      .poll(
+        async () => {
+          const files = await sdk.file
+            .status({ directory: createdDir })
+            .then((r) => r.data ?? [])
+            .catch(() => [])
+          return files.length
+        },
+        { timeout: 60_000 },
+      )
+      .toBe(0)
+
+    await expect.poll(() => fs.readFile(readme, "utf8"), { timeout: 60_000 }).toBe(original)
+
+    await expect
+      .poll(async () => {
+        return await fs
+          .stat(extra)
+          .then(() => true)
+          .catch(() => false)
+      })
+      .toBe(false)
+  })
+})
+
+test("can delete a workspace", async ({ page, withProject }) => {
+  await page.setViewportSize({ width: 1400, height: 800 })
+
+  await withProject(async (project) => {
+    const sdk = createSdk(project.directory)
+    const { rootSlug, slug, directory } = await setupWorkspaceTest(page, project)
+
+    await expect
+      .poll(
+        async () => {
+          const worktrees = await sdk.worktree
+            .list()
+            .then((r) => r.data ?? [])
+            .catch(() => [] as string[])
+          return worktrees.includes(directory)
+        },
+        { timeout: 30_000 },
+      )
+      .toBe(true)
+
+    const menu = await openWorkspaceMenu(page, slug)
+    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
+      .poll(
+        async () => {
+          const worktrees = await sdk.worktree
+            .list()
+            .then((r) => r.data ?? [])
+            .catch(() => [] as string[])
+          return worktrees.includes(directory)
+        },
+        { timeout: 60_000 },
+      )
+      .toBe(false)
+
+    await project.gotoSession()
 
     await openSidebar(page)
-  }
+    await expect(page.locator(workspaceItemSelector(slug))).toHaveCount(0, { timeout: 60_000 })
-
+    await expect(page.locator(workspaceItemSelector(rootSlug)).first()).toBeVisible()
-  if (workspaces.length !== 2) throw new Error("Expected two created workspaces")
+  })
-
-  const a = workspaces[0].slug
-  const b = workspaces[1].slug
-
-  await waitReady(a)
-  await waitReady(b)
-
-  const list = async () => {
-    const slugs = await listSlugs()
-    return slugs.filter((s) => s !== rootSlug && (s === a || s === b)).slice(0, 2)
-  }
-
-  await expect
-    .poll(async () => {
-      const slugs = await list()
-      return slugs.length === 2
-    })
-    .toBe(true)
-
-  const before = await list()
-  const from = before[1]
-  const to = before[0]
-  if (!from || !to) throw new Error("Failed to resolve initial workspace order")
-
-  await drag(from, to)
-
-  await expect.poll(async () => await list()).toEqual([from, to])
 })
 
-test("can delete a workspace", async ({ page, project }) => {
+test("can reorder workspaces by drag and drop", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1400, height: 800 })
-  await project.open()
+  await withProject(async ({ slug: rootSlug }) => {
+    const workspaces = [] as { directory: string; slug: string }[]
 
-  const rootSlug = project.slug
+    const listSlugs = async () => {
-  await openSidebar(page)
+      const nodes = page.locator('[data-component="sidebar-nav-desktop"] [data-component="workspace-item"]')
-  await setWorkspacesEnabled(page, rootSlug, true)
+      const slugs = await nodes.evaluateAll((els) => {
+        return els.map((el) => el.getAttribute("data-workspace") ?? "").filter((x) => x.length > 0)
+      })
+      return slugs
+    }
 
-  const created = await project.sdk.worktree.create({ directory: project.directory }).then((res) => res.data)
+    const waitReady = async (slug: string) => {
-  if (!created?.directory) throw new Error("Failed to create workspace for delete test")
+      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)
+    }
 
-  const directory = created.directory
+    const drag = async (from: string, to: string) => {
-  const slug = dirSlug(directory)
+      const src = page.locator(workspaceItemSelector(from)).first()
-  project.trackDirectory(directory)
+      const dst = page.locator(workspaceItemSelector(to)).first()
 
-  await page.reload()
+      const a = await src.boundingBox()
-  await openSidebar(page)
+      const b = await dst.boundingBox()
-  await expect(page.locator(workspaceItemSelector(slug)).first()).toBeVisible({ timeout: 60_000 })
+      if (!a || !b) throw new Error("Failed to resolve workspace drag bounds")
 
-  await expect
+      await page.mouse.move(a.x + a.width / 2, a.y + a.height / 2)
-    .poll(
+      await page.mouse.down()
-      async () => {
+      await page.mouse.move(b.x + b.width / 2, b.y + b.height / 2, { steps: 12 })
-        const worktrees = await project.sdk.worktree
+      await page.mouse.up()
-          .list()
+    }
-          .then((r) => r.data ?? [])
-          .catch(() => [] as string[])
-        return worktrees.includes(directory)
-      },
-      { timeout: 30_000 },
-    )
-    .toBe(true)
 
-  const menu = await openWorkspaceMenu(page, slug)
+    try {
-  await clickMenuItem(menu, /^Delete$/i, { force: true })
+      await openSidebar(page)
-  await confirmDialog(page, /^Delete workspace$/i)
 
-  await expect.poll(() => base64Decode(slugFromUrl(page.url()))).toBe(project.directory)
+      await setWorkspacesEnabled(page, rootSlug, true)
 
-  await expect
+      for (const _ of [0, 1]) {
-    .poll(
+        const prev = slugFromUrl(page.url())
-      async () => {
+        await page.getByRole("button", { name: "New workspace" }).first().click()
-        const worktrees = await project.sdk.worktree
+        const next = await resolveSlug(await waitSlug(page, [rootSlug, prev]))
-          .list()
+        await waitDir(page, next.directory)
-          .then((r) => r.data ?? [])
+        workspaces.push(next)
-          .catch(() => [] as string[])
-        return worktrees.includes(directory)
-      },
-      { timeout: 60_000 },
-    )
-    .toBe(false)
 
-  await openSidebar(page)
+        await openSidebar(page)
-  await expect(page.locator(workspaceItemSelector(slug))).toHaveCount(0, { timeout: 60_000 })
+      }
-  await expect(page.locator(workspaceItemSelector(rootSlug)).first()).toBeVisible()
+
+      if (workspaces.length !== 2) throw new Error("Expected two created workspaces")
+
+      const a = workspaces[0].slug
+      const b = workspaces[1].slug
+
+      await waitReady(a)
+      await waitReady(b)
+
+      const list = async () => {
+        const slugs = await listSlugs()
+        return slugs.filter((s) => s !== rootSlug && (s === a || s === b)).slice(0, 2)
+      }
+
+      await expect
+        .poll(async () => {
+          const slugs = await list()
+          return slugs.length === 2
+        })
+        .toBe(true)
+
+      const before = await list()
+      const from = before[1]
+      const to = before[0]
+      if (!from || !to) throw new Error("Failed to resolve initial workspace order")
+
+      await drag(from, to)
+
+      await expect.poll(async () => await list()).toEqual([from, to])
+    } finally {
+      await Promise.all(workspaces.map((w) => cleanupTestProject(w.directory)))
+    }
+  })
 })

packages/app/e2e/prompt/mock.ts

@@ -1,15 +0,0 @@
-type Hit = { body: Record<string, unknown> }
-
-export function bodyText(hit: Hit) {
-  return JSON.stringify(hit.body)
-}
-
-/**
- * Match requests whose body contains the exact serialized tool input.
- * The seed prompts embed JSON.stringify(input) in the prompt text, which
- * gets escaped again inside the JSON body — so we double-escape to match.
- */
-export function inputMatch(input: unknown) {
-  const escaped = JSON.stringify(JSON.stringify(input)).slice(1, -1)
-  return (hit: Hit) => bodyText(hit).includes(escaped)
-}

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

@@ -1,25 +1,47 @@
 import { test, expect } from "../fixtures"
 import { promptSelector } from "../selectors"
-import { assistantText, withSession } from "../actions"
+import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"
 
 const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()
 
 // Regression test for Issue #12453: the synchronous POST /message endpoint holds
 // the connection open while the agent works, causing "Failed to fetch" over
 // VPN/Tailscale. The fix switches to POST /prompt_async which returns immediately.
-test("prompt succeeds when sync message endpoint is unreachable", async ({ page, project, assistant }) => {
+test("prompt succeeds when sync message endpoint is unreachable", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
 
   // Simulate Tailscale/VPN killing the long-lived sync connection
   await page.route("**/session/*/message", (route) => route.abort("connectionfailed"))
 
-  const token = `E2E_ASYNC_${Date.now()}`
+  await gotoSession()
-  await project.open()
-  await assistant.reply(token)
-  const sessionID = await project.prompt(`Reply with exactly: ${token}`)
 
-  await expect.poll(() => assistant.calls()).toBeGreaterThanOrEqual(1)
+  const token = `E2E_ASYNC_${Date.now()}`
-  await expect.poll(() => assistantText(project.sdk, sessionID), { timeout: 90_000 }).toContain(token)
+  await page.locator(promptSelector).click()
+  await page.keyboard.type(`Reply with exactly: ${token}`)
+  await page.keyboard.press("Enter")
+
+  await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
+  const sessionID = sessionIDFromUrl(page.url())!
+
+  try {
+    // Agent response arrives via SSE despite sync endpoint being dead
+    await expect
+      .poll(
+        async () => {
+          const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
+          return messages
+            .filter((m) => m.info.role === "assistant")
+            .flatMap((m) => m.parts)
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n")
+        },
+        { timeout: 90_000 },
+      )
+      .toContain(token)
+  } finally {
+    await cleanupSession({ sdk, sessionID })
+  }
 })
 
 test("failed prompt send restores the composer input", async ({ page, sdk, gotoSession }) => {

packages/app/e2e/prompt/prompt-footer-focus.spec.ts

@@ -1,88 +0,0 @@
-import type { Locator, Page } from "@playwright/test"
-import { test, expect } from "../fixtures"
-import { promptAgentSelector, promptModelSelector, promptSelector } from "../selectors"
-
-type Probe = {
-  agent?: string
-  model?: { providerID: string; modelID: string; name?: string }
-  models?: Array<{ providerID: string; modelID: string; name: string }>
-  agents?: Array<{ name: string }>
-}
-
-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 state(page: Page) {
-  const value = await probe(page)
-  if (!value) throw new Error("Failed to resolve model selection probe")
-  return value
-}
-
-async function ready(page: Page) {
-  const prompt = page.locator(promptSelector)
-  await prompt.click()
-  await expect(prompt).toBeFocused()
-  await prompt.pressSequentially("focus")
-  return prompt
-}
-
-async function body(prompt: Locator) {
-  return prompt.evaluate((el) => (el as HTMLElement).innerText)
-}
-
-test("agent select returns focus to the prompt", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const prompt = await ready(page)
-
-  const info = await state(page)
-  const next = info.agents?.map((item) => item.name).find((name) => name !== info.agent)
-  test.skip(!next, "only one agent available")
-  if (!next) return
-
-  await page.locator(`${promptAgentSelector} [data-slot="select-select-trigger"]`).first().click()
-
-  const item = page.locator('[data-slot="select-select-item"]').filter({ hasText: next }).first()
-  await expect(item).toBeVisible()
-  await item.click({ force: true })
-
-  await expect(page.locator(`${promptAgentSelector} [data-slot="select-select-trigger-value"]`).first()).toHaveText(
-    next,
-  )
-  await expect(prompt).toBeFocused()
-  await prompt.pressSequentially(" agent")
-  await expect.poll(() => body(prompt)).toContain("focus agent")
-})
-
-test("model select returns focus to the prompt", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const prompt = await ready(page)
-
-  const info = await state(page)
-  const key = info.model ? `${info.model.providerID}:${info.model.modelID}` : null
-  const next = info.models?.find((item) => `${item.providerID}:${item.modelID}` !== key)
-  test.skip(!next, "only one model available")
-  if (!next) return
-
-  await page.locator(`${promptModelSelector} [data-action="prompt-model"]`).first().click()
-
-  const item = page.locator(`[data-slot="list-item"][data-key="${next.providerID}:${next.modelID}"]`).first()
-  await expect(item).toBeVisible()
-  await item.click({ force: true })
-
-  await expect(page.locator(`${promptModelSelector} [data-action="prompt-model"] span`).first()).toHaveText(next.name)
-  await expect(prompt).toBeFocused()
-  await prompt.pressSequentially(" model")
-  await expect.poll(() => body(prompt)).toContain("focus model")
-})

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

@@ -1,12 +1,10 @@
 import type { ToolPart } from "@opencode-ai/sdk/v2/client"
 import type { Page } from "@playwright/test"
 import { test, expect } from "../fixtures"
-import { assistantText } from "../actions"
+import { withSession } from "../actions"
 import { promptSelector } from "../selectors"
-import { createSdk } from "../utils"
 
 const text = (value: string | null) => (value ?? "").replace(/\u200B/g, "").trim()
-type Sdk = ReturnType<typeof createSdk>
 
 const isBash = (part: unknown): part is ToolPart => {
   if (!part || typeof part !== "object") return false
@@ -15,15 +13,54 @@ const isBash = (part: unknown): part is ToolPart => {
   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: Sdk, sessionID: string, token: string) {
+async function reply(sdk: Parameters<typeof withSession>[0], sessionID: string, token: string) {
-  await expect.poll(() => assistantText(sdk, sessionID), { timeout: 90_000 }).toContain(token)
+  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: Sdk, sessionID: string, cmd: string, token: string) {
+async function shell(sdk: Parameters<typeof withSession>[0], sessionID: string, cmd: string, token: string) {
   await expect
     .poll(
       async () => {
@@ -42,105 +79,103 @@ async function shell(sdk: Sdk, sessionID: string, cmd: string, token: string) {
     .toContain(token)
 }
 
-test("prompt history restores unsent draft with arrow navigation", async ({ page, project, assistant }) => {
+test("prompt history restores unsent draft with arrow navigation", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
 
-  const firstToken = `E2E_HISTORY_ONE_${Date.now()}`
+  await withSession(sdk, `e2e prompt history ${Date.now()}`, async (session) => {
-  const secondToken = `E2E_HISTORY_TWO_${Date.now()}`
+    await gotoSession(session.id)
-  const first = `Reply with exactly: ${firstToken}`
-  const second = `Reply with exactly: ${secondToken}`
-  const draft = `draft ${Date.now()}`
 
-  await project.open()
+    const prompt = page.locator(promptSelector)
-  await assistant.reply(firstToken)
+    const firstToken = `E2E_HISTORY_ONE_${Date.now()}`
-  const sessionID = await project.prompt(first)
+    const secondToken = `E2E_HISTORY_TWO_${Date.now()}`
-  await wait(page, "")
+    const first = `Reply with exactly: ${firstToken}`
-  await reply(project.sdk, sessionID, firstToken)
+    const second = `Reply with exactly: ${secondToken}`
+    const draft = `draft ${Date.now()}`
 
-  await assistant.reply(secondToken)
+    await prompt.click()
-  await project.prompt(second)
+    await page.keyboard.type(first)
-  await wait(page, "")
+    await page.keyboard.press("Enter")
-  await reply(project.sdk, sessionID, secondToken)
+    await wait(page, "")
+    await reply(sdk, session.id, firstToken)
 
-  const prompt = page.locator(promptSelector)
+    await prompt.click()
-  await prompt.click()
+    await page.keyboard.type(second)
-  await page.keyboard.type(draft)
+    await page.keyboard.press("Enter")
-  await wait(page, draft)
+    await wait(page, "")
+    await reply(sdk, session.id, secondToken)
 
-  await prompt.fill("")
+    await prompt.click()
-  await wait(page, "")
+    await page.keyboard.type(draft)
+    await wait(page, draft)
 
-  await page.keyboard.press("ArrowUp")
+    await edge(page, "start")
-  await wait(page, second)
+    await page.keyboard.press("ArrowUp")
+    await wait(page, second)
 
-  await page.keyboard.press("ArrowUp")
+    await page.keyboard.press("ArrowUp")
-  await wait(page, first)
+    await wait(page, first)
 
-  await page.keyboard.press("ArrowDown")
+    await page.keyboard.press("ArrowDown")
-  await wait(page, second)
+    await wait(page, second)
 
-  await page.keyboard.press("ArrowDown")
+    await page.keyboard.press("ArrowDown")
-  await wait(page, "")
+    await wait(page, draft)
+  })
 })
 
-test.fixme("shell history stays separate from normal prompt history", async ({ page, sdk, gotoSession }) => {
+test("shell history stays separate from normal prompt history", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
 
-  const firstToken = `E2E_SHELL_ONE_${Date.now()}`
+  await withSession(sdk, `e2e shell history ${Date.now()}`, async (session) => {
-  const secondToken = `E2E_SHELL_TWO_${Date.now()}`
+    await gotoSession(session.id)
-  const normalToken = `E2E_NORMAL_${Date.now()}`
-  const first = `echo ${firstToken}`
-  const second = `echo ${secondToken}`
-  const normal = `Reply with exactly: ${normalToken}`
 
-  await gotoSession()
+    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}`
 
-  const prompt = page.locator(promptSelector)
+    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 prompt.click()
-  await page.keyboard.type("!")
+    await page.keyboard.type("!")
-  await page.keyboard.type(first)
+    await page.keyboard.type(second)
-  await page.keyboard.press("Enter")
+    await page.keyboard.press("Enter")
-  await wait(page, "")
+    await wait(page, "")
+    await shell(sdk, session.id, second, secondToken)
 
-  await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
+    await prompt.click()
-  const sessionID = sessionIDFromUrl(page.url())!
+    await page.keyboard.type("!")
-  await shell(sdk, sessionID, first, firstToken)
+    await page.keyboard.press("ArrowUp")
+    await wait(page, second)
 
-  await prompt.click()
+    await page.keyboard.press("ArrowUp")
-  await page.keyboard.type("!")
+    await wait(page, first)
-  await page.keyboard.type(second)
-  await page.keyboard.press("Enter")
-  await wait(page, "")
-  await shell(sdk, sessionID, second, secondToken)
 
-  await page.keyboard.press("Escape")
+    await page.keyboard.press("ArrowDown")
-  await wait(page, "")
+    await wait(page, second)
 
-  await prompt.click()
+    await page.keyboard.press("ArrowDown")
-  await page.keyboard.type("!")
+    await wait(page, "")
-  await page.keyboard.press("ArrowUp")
-  await wait(page, second)
 
-  await page.keyboard.press("ArrowUp")
+    await page.keyboard.press("Escape")
-  await wait(page, first)
+    await wait(page, "")
 
-  await page.keyboard.press("ArrowDown")
+    await prompt.click()
-  await wait(page, second)
+    await page.keyboard.type(normal)
+    await page.keyboard.press("Enter")
+    await wait(page, "")
+    await reply(sdk, session.id, normalToken)
 
-  await page.keyboard.press("ArrowDown")
+    await prompt.click()
-  await wait(page, "")
+    await page.keyboard.press("ArrowUp")
-
+    await wait(page, normal)
-  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, sessionID, normalToken)
-
-  await prompt.click()
-  await page.keyboard.press("ArrowUp")
-  await wait(page, normal)
 })

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

@@ -1,7 +1,8 @@
 import type { ToolPart } from "@opencode-ai/sdk/v2/client"
 import { test, expect } from "../fixtures"
-import { closeDialog, openSettings, withSession } from "../actions"
+import { sessionIDFromUrl } from "../actions"
-import { promptModelSelector, promptSelector, promptVariantSelector } from "../selectors"
+import { promptSelector } from "../selectors"
+import { createSdk } from "../utils"
 
 const isBash = (part: unknown): part is ToolPart => {
   if (!part || typeof part !== "object") return false
@@ -10,34 +11,34 @@ const isBash = (part: unknown): part is ToolPart => {
   return "state" in part
 }
 
-test("shell mode runs a command in the project directory", async ({ page, project }) => {
+test("shell mode runs a command in the project directory", async ({ page, withProject }) => {
   test.setTimeout(120_000)
 
-  await project.open()
+  await withProject(async ({ directory, gotoSession, trackSession }) => {
-  const cmd = process.platform === "win32" ? "dir" : "command ls"
+    const sdk = createSdk(directory)
+    const prompt = page.locator(promptSelector)
+    const cmd = process.platform === "win32" ? "dir" : "ls"
 
-  await withSession(project.sdk, `e2e shell ${Date.now()}`, async (session) => {
+    await gotoSession()
-    project.trackSession(session.id)
+    await prompt.click()
-    await project.gotoSession(session.id)
+    await page.keyboard.type("!")
-    const dialog = await openSettings(page)
+    await expect(prompt).toHaveAttribute("aria-label", /enter shell command/i)
-    const toggle = dialog.locator('[data-action="settings-auto-accept-permissions"]').first()
+
-    const input = toggle.locator('[data-slot="switch-input"]').first()
+    await page.keyboard.type(cmd)
-    await expect(toggle).toBeVisible()
+    await page.keyboard.press("Enter")
-    if ((await input.getAttribute("aria-checked")) !== "true") {
+
-      await toggle.locator('[data-slot="switch-control"]').click()
+    await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
-      await expect(input).toHaveAttribute("aria-checked", "true")
+
-    }
+    const id = sessionIDFromUrl(page.url())
-    await closeDialog(page, dialog)
+    if (!id) throw new Error(`Failed to parse session id from url: ${page.url()}`)
-    await project.shell(cmd)
+    trackSession(id, directory)
 
     await expect
       .poll(
         async () => {
-          const list = await project.sdk.session
+          const list = await sdk.session.messages({ sessionID: id, limit: 50 }).then((x) => x.data ?? [])
-            .messages({ sessionID: session.id, limit: 50 })
-            .then((x) => x.data ?? [])
           const msg = list.findLast(
-            (item) => item.info.role === "assistant" && "path" in item.info && item.info.path.cwd === project.directory,
+            (item) => item.info.role === "assistant" && "path" in item.info && item.info.path.cwd === directory,
           )
           if (!msg) return
 
@@ -50,25 +51,12 @@ test("shell mode runs a command in the project directory", async ({ page, projec
             typeof part.state.metadata?.output === "string" ? part.state.metadata.output : part.state.output
           if (!output.includes("README.md")) return
 
-          return { cwd: project.directory, output }
+          return { cwd: directory, output }
         },
         { timeout: 90_000 },
       )
-      .toEqual(expect.objectContaining({ cwd: project.directory, output: expect.stringContaining("README.md") }))
+      .toEqual(expect.objectContaining({ cwd: directory, output: expect.stringContaining("README.md") }))
+
+    await expect(prompt).toHaveText("")
   })
 })
-
-test("shell mode unmounts model and variant controls", async ({ page, project }) => {
-  await project.open()
-
-  const prompt = page.locator(promptSelector).first()
-  await expect(page.locator(promptModelSelector)).toHaveCount(1)
-  await expect(page.locator(promptVariantSelector)).toHaveCount(1)
-
-  await prompt.click()
-  await page.keyboard.type("!")
-
-  await expect(prompt).toHaveAttribute("aria-label", /enter shell command/i)
-  await expect(page.locator(promptModelSelector)).toHaveCount(0)
-  await expect(page.locator(promptVariantSelector)).toHaveCount(0)
-})

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

@@ -22,16 +22,14 @@ async function seed(sdk: Parameters<typeof withSession>[0], sessionID: string) {
     .toBeGreaterThan(0)
 }
 
-test("/share and /unshare update session share state", async ({ page, project }) => {
+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 project.open()
+  await withSession(sdk, `e2e slash share ${Date.now()}`, async (session) => {
-  await withSession(project.sdk, `e2e slash share ${Date.now()}`, async (session) => {
-    project.trackSession(session.id)
     const prompt = page.locator(promptSelector)
 
-    await seed(project.sdk, session.id)
+    await seed(sdk, session.id)
-    await project.gotoSession(session.id)
+    await gotoSession(session.id)
 
     await prompt.click()
     await page.keyboard.type("/share")
@@ -41,7 +39,7 @@ test("/share and /unshare update session share state", async ({ page, project })
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.share?.url || undefined
         },
         { timeout: 30_000 },
@@ -56,7 +54,7 @@ test("/share and /unshare update session share state", async ({ page, project })
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.share?.url || undefined
         },
         { timeout: 30_000 },

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

@@ -1,7 +1,8 @@
 import { test, expect } from "../fixtures"
-import { assistantText } from "../actions"
+import { promptSelector } from "../selectors"
+import { cleanupSession, sessionIDFromUrl, withSession } from "../actions"
 
-test("can send a prompt and receive a reply", async ({ page, project, assistant }) => {
+test("can send a prompt and receive a reply", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
 
   const pageErrors: string[] = []
@@ -10,16 +11,42 @@ test("can send a prompt and receive a reply", async ({ page, project, assistant
   }
   page.on("pageerror", onPageError)
 
-  try {
+  await gotoSession()
-    const token = `E2E_OK_${Date.now()}`
-    await project.open()
-    await assistant.reply(token)
-    const sessionID = await project.prompt(`Reply with exactly: ${token}`)
 
-    await expect.poll(() => assistant.calls()).toBeGreaterThanOrEqual(1)
+  const token = `E2E_OK_${Date.now()}`
-    await expect.poll(() => assistantText(project.sdk, sessionID), { timeout: 30_000 }).toContain(token)
+
+  const prompt = page.locator(promptSelector)
+  await prompt.click()
+  await page.keyboard.type(`Reply with exactly: ${token}`)
+  await page.keyboard.press("Enter")
+
+  await expect(page).toHaveURL(/\/session\/[^/?#]+/, { timeout: 30_000 })
+
+  const sessionID = (() => {
+    const id = sessionIDFromUrl(page.url())
+    if (!id) throw new Error(`Failed to parse session id from url: ${page.url()}`)
+    return id
+  })()
+
+  try {
+    await expect
+      .poll(
+        async () => {
+          const messages = await sdk.session.messages({ sessionID, limit: 50 }).then((r) => r.data ?? [])
+          return messages
+            .filter((m) => m.info.role === "assistant")
+            .flatMap((m) => m.parts)
+            .filter((p) => p.type === "text")
+            .map((p) => p.text)
+            .join("\n")
+        },
+        { timeout: 90_000 },
+      )
+
+      .toContain(token)
   } finally {
     page.off("pageerror", onPageError)
+    await cleanupSession({ sdk, sessionID })
   }
 
   if (pageErrors.length > 0) {

packages/app/e2e/selectors.ts

@@ -1,10 +1,16 @@
 export const promptSelector = '[data-component="prompt-input"]'
-const terminalPanelSelector = '#terminal-panel[aria-hidden="false"]'
+export const terminalPanelSelector = '#terminal-panel[aria-hidden="false"]'
 export const terminalSelector = `${terminalPanelSelector} [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"]'
+export const permissionRejectSelector = `${permissionDockSelector} [data-slot="permission-footer-actions"] [data-component="button"]:nth-child(1)`
+export const permissionAllowAlwaysSelector = `${permissionDockSelector} [data-slot="permission-footer-actions"] [data-component="button"]:nth-child(2)`
+export const permissionAllowOnceSelector = `${permissionDockSelector} [data-slot="permission-footer-actions"] [data-component="button"]:nth-child(3)`
+export const sessionTodoDockSelector = '[data-component="session-todo-dock"]'
+export const sessionTodoToggleSelector = '[data-action="session-todo-toggle"]'
 export const sessionTodoToggleButtonSelector = '[data-action="session-todo-toggle-button"]'
+export const sessionTodoListSelector = '[data-slot="session-todo-list"]'
 
 export const modelVariantCycleSelector = '[data-action="model-variant-cycle"]'
 export const promptAgentSelector = '[data-component="prompt-agent-control"]'
@@ -13,8 +19,7 @@ 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 settingsFontSelector = '[data-action="settings-font"]'
-export const settingsUIFontSelector = '[data-action="settings-ui-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"]'
@@ -24,7 +29,7 @@ export const settingsSoundsErrorsSelector = '[data-action="settings-sounds-error
 export const settingsUpdatesStartupSelector = '[data-action="settings-updates-startup"]'
 export const settingsReleaseNotesSelector = '[data-action="settings-release-notes"]'
 
-const sidebarNavSelector = '[data-component="sidebar-nav-desktop"]'
+export const sidebarNavSelector = '[data-component="sidebar-nav-desktop"]'
 
 export const projectSwitchSelector = (slug: string) =>
   `${sidebarNavSelector} [data-action="project-switch"][data-project="${slug}"]`
@@ -34,6 +39,9 @@ export const projectMenuTriggerSelector = (slug: string) =>
 
 export const projectCloseMenuSelector = (slug: string) => `[data-action="project-close-menu"][data-project="${slug}"]`
 
+export const projectClearNotificationsSelector = (slug: string) =>
+  `[data-action="project-clear-notifications"][data-project="${slug}"]`
+
 export const projectWorkspacesToggleSelector = (slug: string) =>
   `[data-action="project-workspaces-toggle"][data-project="${slug}"]`
 
@@ -41,6 +49,8 @@ export const titlebarRightSelector = "#opencode-titlebar-right"
 
 export const popoverBodySelector = '[data-slot="popover-body"]'
 
+export const dropdownMenuTriggerSelector = '[data-slot="dropdown-menu-trigger"]'
+
 export const dropdownMenuContentSelector = '[data-component="dropdown-menu-content"]'
 
 export const inlineInputSelector = '[data-component="inline-input"]'

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

@@ -1,8 +1,7 @@
 import { seedSessionTask, withSession } from "../actions"
 import { test, expect } from "../fixtures"
-import { inputMatch } from "../prompt/mock"
 
-test("task tool child-session link does not trigger stale show errors", async ({ page, llm, project }) => {
+test("task tool child-session link does not trigger stale show errors", async ({ page, sdk, gotoSession }) => {
   test.setTimeout(120_000)
 
   const errs: string[] = []
@@ -11,54 +10,28 @@ test("task tool child-session link does not trigger stale show errors", async ({
   }
   page.on("pageerror", onError)
 
-  try {
+  await withSession(sdk, `e2e child nav ${Date.now()}`, async (session) => {
-    await project.open()
+    const child = await seedSessionTask(sdk, {
-    await withSession(project.sdk, `e2e child nav ${Date.now()}`, async (session) => {
+      sessionID: session.id,
-      const taskInput = {
+      description: "Open child session",
-        description: "Open child session",
+      prompt: "Search the repository for AssistantParts and then reply with exactly CHILD_OK.",
-        prompt: "Search the repository for AssistantParts and then reply with exactly CHILD_OK.",
+    })
-        subagent_type: "general",
-      }
-      await llm.toolMatch(inputMatch(taskInput), "task", taskInput)
-      const child = await seedSessionTask(project.sdk, {
-        sessionID: session.id,
-        description: taskInput.description,
-        prompt: taskInput.prompt,
-      })
-      project.trackSession(child.sessionID)
 
-      await project.gotoSession(session.id)
+    try {
+      await gotoSession(session.id)
 
-      const header = page.locator("[data-session-title]")
+      const link = page
-      await expect(header.getByRole("button", { name: "More options" })).toBeVisible({ timeout: 30_000 })
+        .locator("a.subagent-link")
-
-      const card = page
-        .locator('[data-component="task-tool-card"]')
         .filter({ hasText: /open child session/i })
         .first()
-      await expect(card).toBeVisible({ timeout: 30_000 })
+      await expect(link).toBeVisible({ timeout: 30_000 })
-      await card.click()
+      await link.click()
 
       await expect(page).toHaveURL(new RegExp(`/session/${child.sessionID}(?:[/?#]|$)`), { timeout: 30_000 })
-      await expect(header.locator('[data-slot="session-title-parent"]')).toHaveText(session.title)
+      await page.waitForTimeout(1000)
-      await expect(header.locator('[data-slot="session-title-child"]')).toHaveText(taskInput.description)
+      expect(errs).toEqual([])
-      await expect(header.locator('[data-slot="session-title-separator"]')).toHaveText("/")
+    } finally {
-      await expect
+      page.off("pageerror", onError)
-        .poll(
+    }
-          () =>
+  })
-            header.locator('[data-slot="session-title-separator"]').evaluate((el) => ({
-              left: getComputedStyle(el).paddingLeft,
-              right: getComputedStyle(el).paddingRight,
-            })),
-          { timeout: 30_000 },
-        )
-        .toEqual({ left: "8px", right: "8px" })
-      await expect(header.getByRole("button", { name: "More options" })).toHaveCount(0)
-      await expect(page.getByText("Subagent sessions cannot be prompted.")).toBeVisible({ timeout: 30_000 })
-      await expect(page.getByRole("button", { name: "Back to main session." })).toBeVisible({ timeout: 30_000 })
-      await expect.poll(() => errs, { timeout: 5_000 }).toEqual([])
-    })
-  } finally {
-    page.off("pageerror", onError)
-  }
 })

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

@@ -5,7 +5,7 @@ import {
   type ComposerProbeState,
   type ComposerWindow,
 } from "../../src/testing/session-composer"
-import { cleanupSession, clearSessionDockSeed, closeDialog, openSettings, seedSessionQuestion } from "../actions"
+import { cleanupSession, clearSessionDockSeed, seedSessionQuestion } from "../actions"
 import {
   permissionDockSelector,
   promptSelector,
@@ -13,8 +13,6 @@ import {
   sessionComposerDockSelector,
   sessionTodoToggleButtonSelector,
 } from "../selectors"
-import { modKey } from "../utils"
-import { inputMatch } from "../prompt/mock"
 
 type Sdk = Parameters<typeof clearSessionDockSeed>[0]
 type PermissionRule = { permission: string; pattern: string; action: "allow" | "deny" | "ask" }
@@ -23,13 +21,12 @@ async function withDockSession<T>(
   sdk: Sdk,
   title: string,
   fn: (session: { id: string; title: string }) => Promise<T>,
-  opts?: { permission?: PermissionRule[]; trackSession?: (sessionID: string) => void },
+  opts?: { permission?: PermissionRule[] },
 ) {
   const session = await sdk.session
     .create(opts?.permission ? { title, permission: opts.permission } : { title })
     .then((r) => r.data)
   if (!session?.id) throw new Error("Session create did not return an id")
-  opts?.trackSession?.(session.id)
   try {
     return await fn(session)
   } finally {
@@ -37,17 +34,6 @@ async function withDockSession<T>(
   }
 }
 
-const defaultQuestions = [
-  {
-    header: "Need input",
-    question: "Pick one option",
-    options: [
-      { label: "Continue", description: "Continue now" },
-      { label: "Stop", description: "Stop here" },
-    ],
-  },
-]
-
 test.setTimeout(120_000)
 
 async function withDockSeed<T>(sdk: Sdk, sessionID: string, fn: () => Promise<T>) {
@@ -65,14 +51,12 @@ async function clearPermissionDock(page: any, label: RegExp) {
 }
 
 async function setAutoAccept(page: any, enabled: boolean) {
-  const dialog = await openSettings(page)
+  const button = page.locator('[data-action="prompt-permissions"]').first()
-  const toggle = dialog.locator('[data-action="settings-auto-accept-permissions"]').first()
+  await expect(button).toBeVisible()
-  const input = toggle.locator('[data-slot="switch-input"]').first()
+  const pressed = (await button.getAttribute("aria-pressed")) === "true"
-  await expect(toggle).toBeVisible()
+  if (pressed === enabled) return
-  const checked = (await input.getAttribute("aria-checked")) === "true"
+  await button.click()
-  if (checked !== enabled) await toggle.locator('[data-slot="switch-control"]').click()
+  await expect(button).toHaveAttribute("aria-pressed", enabled ? "true" : "false")
-  await expect(input).toHaveAttribute("aria-checked", enabled ? "true" : "false")
-  await closeDialog(page, dialog)
 }
 
 async function expectQuestionBlocked(page: any) {
@@ -109,7 +93,7 @@ async function todoDock(page: any, sessionID: string) {
 
   const write = async (driver: ComposerDriverState | undefined) => {
     await page.evaluate(
-      (input: { event: string; sessionID: string; driver: ComposerDriverState | undefined }) => {
+      (input) => {
         const win = window as ComposerWindow
         const composer = win.__opencode_e2e?.composer
         if (!composer?.enabled) throw new Error("Composer e2e driver is not enabled")
@@ -134,7 +118,7 @@ async function todoDock(page: any, sessionID: string) {
   }
 
   const read = () =>
-    page.evaluate((sessionID: string) => {
+    page.evaluate((sessionID) => {
       const win = window as ComposerWindow
       return win.__opencode_e2e?.composer?.sessions?.[sessionID]?.probe ?? null
     }, sessionID) as Promise<ComposerProbeState | null>
@@ -202,8 +186,6 @@ async function withMockPermission<T>(
   opts: { child?: any } | undefined,
   fn: (state: { resolved: () => Promise<void> }) => Promise<T>,
 ) {
-  const listUrl = /\/permission(?:\?.*)?$/
-  const replyUrls = [/\/session\/[^/]+\/permissions\/[^/?]+(?:\?.*)?$/, /\/permission\/[^/]+\/reply(?:\?.*)?$/]
   let pending = [
     {
       ...request,
@@ -222,8 +204,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 = url.pathname.split("/").pop()
-    const id = parts.at(-1) === "reply" ? parts.at(-2) : parts.at(-1)
     pending = pending.filter((item) => item.id !== id)
     await route.fulfill({
       status: 200,
@@ -232,10 +213,8 @@ async function withMockPermission<T>(
     })
   }
 
-  await page.route(listUrl, list)
+  await page.route("**/permission", list)
-  for (const item of replyUrls) {
+  await page.route("**/session/*/permissions/*", reply)
-    await page.route(item, reply)
-  }
 
   const sessionList = opts?.child
     ? async (route: any) => {
@@ -244,7 +223,9 @@ async function withMockPermission<T>(
         const list = Array.isArray(json) ? json : Array.isArray(json?.data) ? json.data : undefined
         if (Array.isArray(list) && !list.some((item) => item?.id === opts.child?.id)) list.push(opts.child)
         await route.fulfill({
-          response: res,
+          status: res.status(),
+          headers: res.headers(),
+          contentType: "application/json",
           body: JSON.stringify(json),
         })
       }
@@ -261,55 +242,177 @@ async function withMockPermission<T>(
   try {
     return await fn(state)
   } finally {
-    await page.unroute(listUrl, list)
+    await page.unroute("**/permission", list)
-    for (const item of replyUrls) {
+    await page.unroute("**/session/*/permissions/*", reply)
-      await page.unroute(item, reply)
-    }
     if (sessionList) await page.unroute("**/session?*", sessionList)
   }
 }
 
-test("default dock shows prompt input", async ({ page, project }) => {
+test("default dock shows prompt input", async ({ page, sdk, gotoSession }) => {
-  await project.open()
+  await withDockSession(sdk, "e2e composer dock default", async (session) => {
-  await withDockSession(
+    await gotoSession(session.id)
-    project.sdk,
-    "e2e composer dock default",
-    async (session) => {
-      await project.gotoSession(session.id)
 
-      await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
+    await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
-      await expect(page.locator(promptSelector)).toBeVisible()
+    await expect(page.locator(promptSelector)).toBeVisible()
-      await expect(page.locator('[data-action="prompt-permissions"]')).toHaveCount(0)
+    await expect(page.locator(questionDockSelector)).toHaveCount(0)
-      await expect(page.locator(questionDockSelector)).toHaveCount(0)
+    await expect(page.locator(permissionDockSelector)).toHaveCount(0)
-      await expect(page.locator(permissionDockSelector)).toHaveCount(0)
 
-      await page.locator(promptSelector).click()
+    await page.locator(promptSelector).click()
-      await expect(page.locator(promptSelector)).toBeFocused()
+    await expect(page.locator(promptSelector)).toBeFocused()
-    },
+  })
-    { trackSession: project.trackSession },
-  )
 })
 
-test("auto-accept toggle works before first submit", async ({ page, project }) => {
+test("auto-accept toggle works before first submit", async ({ page, gotoSession }) => {
-  await project.open()
+  await gotoSession()
+
+  const button = page.locator('[data-action="prompt-permissions"]').first()
+  await expect(button).toBeVisible()
+  await expect(button).toHaveAttribute("aria-pressed", "false")
 
   await setAutoAccept(page, true)
   await setAutoAccept(page, false)
 })
 
-test("blocked question flow unblocks after submit", async ({ page, llm, project }) => {
+test("blocked question flow unblocks after submit", async ({ page, sdk, gotoSession }) => {
-  await project.open()
+  await withDockSession(sdk, "e2e composer dock question", async (session) => {
-  await withDockSession(
+    await withDockSeed(sdk, session.id, async () => {
-    project.sdk,
+      await gotoSession(session.id)
-    "e2e composer dock question",
-    async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
 
-        await llm.toolMatch(inputMatch({ questions: defaultQuestions }), "question", { questions: defaultQuestions })
+      await seedSessionQuestion(sdk, {
-        await seedSessionQuestion(project.sdk, {
+        sessionID: session.id,
-          sessionID: session.id,
+        questions: [
-          questions: defaultQuestions,
+          {
+            header: "Need input",
+            question: "Pick one option",
+            options: [
+              { label: "Continue", description: "Continue now" },
+              { label: "Stop", description: "Stop here" },
+            ],
+          },
+        ],
+      })
+
+      const dock = page.locator(questionDockSelector)
+      await expectQuestionBlocked(page)
+
+      await dock.locator('[data-slot="question-option"]').first().click()
+      await dock.getByRole("button", { name: /submit/i }).click()
+
+      await expectQuestionOpen(page)
+    })
+  })
+})
+
+test("blocked permission flow supports allow once", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission once", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_once",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-once"],
+        metadata: { description: "Need permission for command" },
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)
+
+        await clearPermissionDock(page, /allow once/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
+  })
+})
+
+test("blocked permission flow supports reject", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission reject", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_reject",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-reject"],
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)
+
+        await clearPermissionDock(page, /deny/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
+  })
+})
+
+test("blocked permission flow supports allow always", async ({ page, sdk, gotoSession }) => {
+  await withDockSession(sdk, "e2e composer dock permission always", async (session) => {
+    await gotoSession(session.id)
+    await setAutoAccept(page, false)
+    await withMockPermission(
+      page,
+      {
+        id: "per_e2e_always",
+        sessionID: session.id,
+        permission: "bash",
+        patterns: ["/tmp/opencode-e2e-perm-always"],
+        metadata: { description: "Need permission for command" },
+      },
+      undefined,
+      async (state) => {
+        await page.goto(page.url())
+        await expectPermissionBlocked(page)
+
+        await clearPermissionDock(page, /allow always/i)
+        await state.resolved()
+        await page.goto(page.url())
+        await expectPermissionOpen(page)
+      },
+    )
+  })
+})
+
+test("child session question request blocks parent dock and unblocks after submit", async ({
+  page,
+  sdk,
+  gotoSession,
+}) => {
+  await withDockSession(sdk, "e2e composer dock child question parent", async (session) => {
+    await gotoSession(session.id)
+
+    const child = await sdk.session
+      .create({
+        title: "e2e composer dock child question",
+        parentID: session.id,
+      })
+      .then((r) => r.data)
+    if (!child?.id) throw new Error("Child session create did not return an id")
+
+    try {
+      await withDockSeed(sdk, child.id, async () => {
+        await seedSessionQuestion(sdk, {
+          sessionID: child.id,
+          questions: [
+            {
+              header: "Child input",
+              question: "Pick one child option",
+              options: [
+                { label: "Continue", description: "Continue child" },
+                { label: "Stop", description: "Stop child" },
+              ],
+            },
+          ],
         })
 
         const dock = page.locator(questionDockSelector)
@@ -320,92 +423,40 @@ test("blocked question flow unblocks after submit", async ({ page, llm, project
 
         await expectQuestionOpen(page)
       })
-    },
+    } finally {
-    { trackSession: project.trackSession },
+      await cleanupSession({ sdk, sessionID: child.id })
-  )
+    }
+  })
 })
 
-test("blocked question flow supports keyboard shortcuts", async ({ page, llm, project }) => {
+test("child session permission request blocks parent dock and supports allow once", async ({
-  await project.open()
+  page,
-  await withDockSession(
+  sdk,
-    project.sdk,
+  gotoSession,
-    "e2e composer dock question keyboard",
+}) => {
-    async (session) => {
+  await withDockSession(sdk, "e2e composer dock child permission parent", async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
+    await gotoSession(session.id)
-        await project.gotoSession(session.id)
+    await setAutoAccept(page, false)
 
-        await llm.toolMatch(inputMatch({ questions: defaultQuestions }), "question", { questions: defaultQuestions })
+    const child = await sdk.session
-        await seedSessionQuestion(project.sdk, {
+      .create({
-          sessionID: session.id,
+        title: "e2e composer dock child permission",
-          questions: defaultQuestions,
+        parentID: session.id,
-        })
-
-        const dock = page.locator(questionDockSelector)
-        const first = dock.locator('[data-slot="question-option"]').first()
-        const second = dock.locator('[data-slot="question-option"]').nth(1)
-
-        await expectQuestionBlocked(page)
-        await expect(first).toBeFocused()
-
-        await page.keyboard.press("ArrowDown")
-        await expect(second).toBeFocused()
-
-        await page.keyboard.press("Space")
-        await page.keyboard.press(`${modKey}+Enter`)
-        await expectQuestionOpen(page)
       })
-    },
+      .then((r) => r.data)
-    { trackSession: project.trackSession },
+    if (!child?.id) throw new Error("Child session create did not return an id")
-  )
-})
 
-test("blocked question flow supports escape dismiss", async ({ page, llm, project }) => {
+    try {
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock question escape",
-    async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
-
-        await llm.toolMatch(inputMatch({ questions: defaultQuestions }), "question", { questions: defaultQuestions })
-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
-          questions: defaultQuestions,
-        })
-
-        const dock = page.locator(questionDockSelector)
-        const first = dock.locator('[data-slot="question-option"]').first()
-
-        await expectQuestionBlocked(page)
-        await expect(first).toBeFocused()
-
-        await page.keyboard.press("Escape")
-        await expectQuestionOpen(page)
-      })
-    },
-    { trackSession: project.trackSession },
-  )
-})
-
-test("blocked permission flow supports allow once", async ({ page, project }) => {
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock permission once",
-    async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
       await withMockPermission(
         page,
         {
-          id: "per_e2e_once",
+          id: "per_e2e_child",
-          sessionID: session.id,
+          sessionID: child.id,
           permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-once"],
+          patterns: ["/tmp/opencode-e2e-perm-child"],
-          metadata: { description: "Need permission for command" },
+          metadata: { description: "Need child permission" },
         },
-        undefined,
+        { child },
         async (state) => {
           await page.goto(page.url())
           await expectPermissionBlocked(page)
@@ -413,243 +464,67 @@ test("blocked permission flow supports allow once", async ({ page, project }) =>
           await clearPermissionDock(page, /allow once/i)
           await state.resolved()
           await page.goto(page.url())
+
           await expectPermissionOpen(page)
         },
       )
-    },
+    } finally {
-    { trackSession: project.trackSession },
+      await cleanupSession({ sdk, sessionID: child.id })
-  )
+    }
+  })
 })
 
-test("blocked permission flow supports reject", async ({ page, project }) => {
+test("todo dock transitions and collapse behavior", async ({ page, sdk, gotoSession }) => {
-  await project.open()
+  await withDockSession(sdk, "e2e composer dock todo", async (session) => {
-  await withDockSession(
+    const dock = await todoDock(page, session.id)
-    project.sdk,
+    await gotoSession(session.id)
-    "e2e composer dock permission reject",
+    await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
-    async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-      await withMockPermission(
-        page,
-        {
-          id: "per_e2e_reject",
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-reject"],
-        },
-        undefined,
-        async (state) => {
-          await page.goto(page.url())
-          await expectPermissionBlocked(page)
 
-          await clearPermissionDock(page, /deny/i)
+    try {
-          await state.resolved()
+      await dock.open([
-          await page.goto(page.url())
+        { content: "first task", status: "pending", priority: "high" },
-          await expectPermissionOpen(page)
+        { content: "second task", status: "in_progress", priority: "medium" },
-        },
+      ])
-      )
+      await dock.expectOpen(["pending", "in_progress"])
-    },
+
-    { trackSession: project.trackSession },
+      await dock.collapse()
-  )
+      await dock.expectCollapsed(["pending", "in_progress"])
+
+      await dock.expand()
+      await dock.expectOpen(["pending", "in_progress"])
+
+      await dock.finish([
+        { content: "first task", status: "completed", priority: "high" },
+        { content: "second task", status: "cancelled", priority: "medium" },
+      ])
+      await dock.expectClosed()
+    } finally {
+      await dock.clear()
+    }
+  })
 })
 
-test("blocked permission flow supports allow always", async ({ page, project }) => {
+test("keyboard focus stays off prompt while blocked", async ({ page, sdk, gotoSession }) => {
-  await project.open()
+  await withDockSession(sdk, "e2e composer dock keyboard", async (session) => {
-  await withDockSession(
+    await withDockSeed(sdk, session.id, async () => {
-    project.sdk,
+      await gotoSession(session.id)
-    "e2e composer dock permission always",
-    async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-      await withMockPermission(
-        page,
-        {
-          id: "per_e2e_always",
-          sessionID: session.id,
-          permission: "bash",
-          patterns: ["/tmp/opencode-e2e-perm-always"],
-          metadata: { description: "Need permission for command" },
-        },
-        undefined,
-        async (state) => {
-          await page.goto(page.url())
-          await expectPermissionBlocked(page)
 
-          await clearPermissionDock(page, /allow always/i)
+      await seedSessionQuestion(sdk, {
-          await state.resolved()
+        sessionID: session.id,
-          await page.goto(page.url())
+        questions: [
-          await expectPermissionOpen(page)
-        },
-      )
-    },
-    { trackSession: project.trackSession },
-  )
-})
-
-test("child session question request blocks parent dock and unblocks after submit", async ({ page, llm, project }) => {
-  const questions = [
-    {
-      header: "Child input",
-      question: "Pick one child option",
-      options: [
-        { label: "Continue", description: "Continue child" },
-        { label: "Stop", description: "Stop child" },
-      ],
-    },
-  ]
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock child question parent",
-    async (session) => {
-      await project.gotoSession(session.id)
-
-      const child = await project.sdk.session
-        .create({
-          title: "e2e composer dock child question",
-          parentID: session.id,
-        })
-        .then((r) => r.data)
-      if (!child?.id) throw new Error("Child session create did not return an id")
-      project.trackSession(child.id)
-
-      try {
-        await withDockSeed(project.sdk, child.id, async () => {
-          await llm.toolMatch(inputMatch({ questions }), "question", { questions })
-          await seedSessionQuestion(project.sdk, {
-            sessionID: child.id,
-            questions,
-          })
-
-          const dock = page.locator(questionDockSelector)
-          await expectQuestionBlocked(page)
-
-          await dock.locator('[data-slot="question-option"]').first().click()
-          await dock.getByRole("button", { name: /submit/i }).click()
-
-          await expectQuestionOpen(page)
-        })
-      } finally {
-        await cleanupSession({ sdk: project.sdk, sessionID: child.id })
-      }
-    },
-    { trackSession: project.trackSession },
-  )
-})
-
-test("child session permission request blocks parent dock and supports allow once", async ({ page, project }) => {
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock child permission parent",
-    async (session) => {
-      await project.gotoSession(session.id)
-      await setAutoAccept(page, false)
-
-      const child = await project.sdk.session
-        .create({
-          title: "e2e composer dock child permission",
-          parentID: session.id,
-        })
-        .then((r) => r.data)
-      if (!child?.id) throw new Error("Child session create did not return an id")
-      project.trackSession(child.id)
-
-      try {
-        await withMockPermission(
-          page,
           {
-            id: "per_e2e_child",
+            header: "Need input",
-            sessionID: child.id,
+            question: "Pick one option",
-            permission: "bash",
+            options: [{ label: "Continue", description: "Continue now" }],
-            patterns: ["/tmp/opencode-e2e-perm-child"],
-            metadata: { description: "Need child permission" },
           },
-          { child },
+        ],
-          async (state) => {
-            await page.goto(page.url())
-            await expectPermissionBlocked(page)
-
-            await clearPermissionDock(page, /allow once/i)
-            await state.resolved()
-            await page.goto(page.url())
-
-            await expectPermissionOpen(page)
-          },
-        )
-      } finally {
-        await cleanupSession({ sdk: project.sdk, sessionID: child.id })
-      }
-    },
-    { trackSession: project.trackSession },
-  )
-})
-
-test("todo dock transitions and collapse behavior", async ({ page, project }) => {
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock todo",
-    async (session) => {
-      const dock = await todoDock(page, session.id)
-      await project.gotoSession(session.id)
-      await expect(page.locator(sessionComposerDockSelector)).toBeVisible()
-
-      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 dock.collapse()
-        await dock.expectCollapsed(["pending", "in_progress"])
-
-        await dock.expand()
-        await dock.expectOpen(["pending", "in_progress"])
-
-        await dock.finish([
-          { content: "first task", status: "completed", priority: "high" },
-          { content: "second task", status: "cancelled", priority: "medium" },
-        ])
-        await dock.expectClosed()
-      } finally {
-        await dock.clear()
-      }
-    },
-    { trackSession: project.trackSession },
-  )
-})
-
-test("keyboard focus stays off prompt while blocked", async ({ page, llm, project }) => {
-  const questions = [
-    {
-      header: "Need input",
-      question: "Pick one option",
-      options: [{ label: "Continue", description: "Continue now" }],
-    },
-  ]
-  await project.open()
-  await withDockSession(
-    project.sdk,
-    "e2e composer dock keyboard",
-    async (session) => {
-      await withDockSeed(project.sdk, session.id, async () => {
-        await project.gotoSession(session.id)
-
-        await llm.toolMatch(inputMatch({ questions }), "question", { questions })
-        await seedSessionQuestion(project.sdk, {
-          sessionID: session.id,
-          questions,
-        })
-
-        await expectQuestionBlocked(page)
-
-        await page.locator("main").click({ position: { x: 5, y: 5 } })
-        await page.keyboard.type("abc")
-        await expect(page.locator(promptSelector)).toHaveCount(0)
       })
-    },
+
-    { trackSession: project.trackSession },
+      await expectQuestionBlocked(page)
-  )
+
+      await page.locator("main").click({ position: { x: 5, y: 5 } })
+      await page.keyboard.type("abc")
+      await expect(page.locator(promptSelector)).toHaveCount(0)
+    })
+  })
 })

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

@@ -1,9 +1,18 @@
 import type { Locator, Page } from "@playwright/test"
 import { test, expect } from "../fixtures"
-import { openSidebar, resolveSlug, setWorkspacesEnabled, waitSession, waitSlug } from "../actions"
+import {
+  openSidebar,
+  resolveSlug,
+  sessionIDFromUrl,
+  setWorkspacesEnabled,
+  waitSession,
+  waitSessionIdle,
+  waitSlug,
+} from "../actions"
 import {
   promptAgentSelector,
   promptModelSelector,
+  promptSelector,
   promptVariantSelector,
   workspaceItemSelector,
   workspaceNewSessionSelector,
@@ -19,17 +28,7 @@ type Footer = {
 type Probe = {
   dir?: string
   sessionID?: string
-  agent?: string
+  model?: { providerID: string; modelID: 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, "\\$&")
@@ -51,86 +50,6 @@ async function probe(page: Page): Promise<Probe | 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()),
@@ -163,15 +82,31 @@ async function waitModel(page: Page, value: string) {
 async function choose(page: Page, root: string, value: string) {
   const select = page.locator(root)
   await expect(select).toBeVisible()
-  await pickAgent(page, value)
+  await select.locator('[data-action], [data-slot="select-select-trigger"]').first().click()
+  const item = page
+    .locator('[data-slot="select-select-item"]')
+    .filter({ hasText: new RegExp(`^\\s*${escape(value)}\\s*$`) })
+    .first()
+  await expect(item).toBeVisible()
+  await item.click()
 }
 
 async function variantCount(page: Page) {
-  return (await probe(page))?.variants?.length ?? 0
+  const select = page.locator(promptVariantSelector)
+  await expect(select).toBeVisible()
+  await select.locator('[data-slot="select-select-trigger"]').click()
+  const count = await page.locator('[data-slot="select-select-item"]').count()
+  await page.keyboard.press("Escape")
+  return count
 }
 
 async function agents(page: Page) {
-  return ((await probe(page))?.agents ?? []).map((item) => item.name).filter(Boolean)
+  const select = page.locator(promptAgentSelector)
+  await expect(select).toBeVisible()
+  await select.locator('[data-action], [data-slot="select-select-trigger"]').first().click()
+  const labels = await page.locator('[data-slot="select-select-item-label"]').allTextContents()
+  await page.keyboard.press("Escape")
+  return labels.map((item) => item.trim()).filter(Boolean)
 }
 
 async function ensureVariant(page: Page, directory: string): Promise<Footer> {
@@ -197,23 +132,48 @@ async function ensureVariant(page: Page, directory: string): Promise<Footer> {
 
 async function chooseDifferentVariant(page: Page): Promise<Footer> {
   const current = await read(page)
-  const next = (await probe(page))?.variants?.find((item) => item !== current.variant)
+  const select = page.locator(promptVariantSelector)
-  if (!next) throw new Error("Current model has no alternate variant to select")
+  await expect(select).toBeVisible()
+  await select.locator('[data-slot="select-select-trigger"]').click()
 
-  await pickVariant(page, next)
+  const items = page.locator('[data-slot="select-select-item"]')
-  return waitFooter(page, { agent: current.agent, model: current.model, variant: next })
+  const count = await items.count()
+  if (count < 2) throw new Error("Current model has no alternate variant to select")
+
+  for (let i = 0; i < count; i++) {
+    const item = items.nth(i)
+    const next = await text(item.locator('[data-slot="select-select-item-label"]').first())
+    if (!next || next === current.variant) continue
+    await item.click()
+    return waitFooter(page, { agent: current.agent, model: current.model, variant: next })
+  }
+
+  throw new Error("Failed to choose a different variant")
 }
 
-async function chooseOtherModel(page: Page, skip: string[] = []): Promise<Footer> {
+async function chooseOtherModel(page: Page): Promise<Footer> {
-  const current = await currentModel(page)
+  const current = await read(page)
-  const next = (await probe(page))?.models?.find((item) => {
+  const button = page.locator(`${promptModelSelector} [data-action="prompt-model"]`)
-    const key = `${item.providerID}:${item.modelID}`
+  await expect(button).toBeVisible()
-    return key !== current && !skip.includes(key)
+  await button.click()
-  })
+
-  if (!next) throw new Error("Failed to choose a different model")
+  const dialog = page.getByRole("dialog")
-  await pickModel(page, { providerID: next.providerID, modelID: next.modelID })
+  await expect(dialog).toBeVisible()
-  await expect.poll(async () => (await read(page)).model, { timeout: 30_000 }).toBe(next.name)
+  const items = dialog.locator('[data-slot="list-item"]')
-  return read(page)
+  const count = await items.count()
+  expect(count).toBeGreaterThan(1)
+
+  for (let i = 0; i < count; i++) {
+    const item = items.nth(i)
+    const selected = (await item.getAttribute("data-selected")) === "true"
+    if (selected) continue
+    await item.click()
+    await expect(dialog).toHaveCount(0)
+    await expect.poll(async () => (await read(page)).model !== current.model, { timeout: 30_000 }).toBe(true)
+    return read(page)
+  }
+
+  throw new Error("Failed to choose a different model")
 }
 
 async function goto(page: Page, directory: string, sessionID?: string) {
@@ -221,8 +181,32 @@ async function goto(page: Page, directory: string, sessionID?: string) {
   await waitSession(page, { directory, sessionID })
 }
 
-async function submit(project: Parameters<typeof test>[0]["project"], value: string) {
+async function submit(page: Page, value: string) {
-  return project.prompt(value)
+  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[]) {
@@ -265,98 +249,111 @@ async function newWorkspaceSession(page: Page, slug: string) {
   return waitSession(page, { directory: next.directory }).then((item) => item.directory)
 }
 
-test("session model restore per session without leaking into new sessions", async ({ page, project }) => {
+test("session model and variant restore per session without leaking into new sessions", async ({
+  page,
+  withProject,
+}) => {
   await page.setViewportSize({ width: 1440, height: 900 })
 
-  await project.open()
+  await withProject(async ({ directory, gotoSession, trackSession }) => {
-  await project.gotoSession()
+    await gotoSession()
 
-  const firstState = await chooseOtherModel(page)
+    await ensureVariant(page, directory)
-  const firstKey = await currentModel(page)
+    const firstState = await chooseDifferentVariant(page)
-  const first = await submit(project, `session variant ${Date.now()}`)
+    const first = await submit(page, `session variant ${Date.now()}`)
+    trackSession(first)
+    await waitUser(directory, first)
 
-  await page.reload()
+    await page.reload()
-  await waitSession(page, { directory: project.directory, sessionID: first })
+    await waitSession(page, { directory, sessionID: first })
-  await waitFooter(page, firstState)
+    await waitFooter(page, firstState)
 
-  await project.gotoSession()
+    await gotoSession()
-  const fresh = await read(page)
+    const fresh = await ensureVariant(page, directory)
-  expect(fresh.model).not.toBe(firstState.model)
+    expect(fresh.variant).not.toBe(firstState.variant)
 
-  const secondState = await chooseOtherModel(page, [firstKey])
+    const secondState = await chooseOtherModel(page)
-  const second = await submit(project, `session model ${Date.now()}`)
+    const second = await submit(page, `session model ${Date.now()}`)
+    trackSession(second)
+    await waitUser(directory, second)
 
-  await goto(page, project.directory, first)
+    await goto(page, directory, first)
-  await waitFooter(page, firstState)
+    await waitFooter(page, firstState)
 
-  await goto(page, project.directory, second)
+    await goto(page, directory, second)
-  await waitFooter(page, secondState)
+    await waitFooter(page, secondState)
 
-  await project.gotoSession()
+    await gotoSession()
-  await page.reload()
+    await waitFooter(page, fresh)
-  await waitSession(page, { directory: project.directory })
+  })
-  await waitFooter(page, fresh)
 })
 
-test("session model restore across workspaces", async ({ page, project }) => {
+test("session model restore across workspaces", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1440, height: 900 })
 
-  await project.open()
+  await withProject(async ({ directory: root, slug, gotoSession, trackDirectory, trackSession }) => {
-  const root = project.directory
+    await gotoSession()
-  await project.gotoSession()
 
-  const firstState = await chooseOtherModel(page)
+    await ensureVariant(page, root)
-  const firstKey = await currentModel(page)
+    const firstState = await chooseDifferentVariant(page)
-  const first = await submit(project, `root session ${Date.now()}`)
+    const first = await submit(page, `root session ${Date.now()}`)
+    trackSession(first, root)
+    await waitUser(root, first)
 
-  await openSidebar(page)
+    await openSidebar(page)
-  await setWorkspacesEnabled(page, project.slug, true)
+    await setWorkspacesEnabled(page, slug, true)
 
-  const one = await createWorkspace(page, project.slug, [])
+    const one = await createWorkspace(page, slug, [])
-  const oneDir = await newWorkspaceSession(page, one.slug)
+    const oneDir = await newWorkspaceSession(page, one.slug)
-  project.trackDirectory(oneDir)
+    trackDirectory(oneDir)
 
-  const secondState = await chooseOtherModel(page, [firstKey])
+    const secondState = await chooseOtherModel(page)
-  const secondKey = await currentModel(page)
+    const second = await submit(page, `workspace one ${Date.now()}`)
-  const second = await submit(project, `workspace one ${Date.now()}`)
+    trackSession(second, oneDir)
+    await waitUser(oneDir, second)
 
-  const two = await createWorkspace(page, project.slug, [one.slug])
+    const two = await createWorkspace(page, slug, [one.slug])
-  const twoDir = await newWorkspaceSession(page, two.slug)
+    const twoDir = await newWorkspaceSession(page, two.slug)
-  project.trackDirectory(twoDir)
+    trackDirectory(twoDir)
 
-  const thirdState = await chooseOtherModel(page, [firstKey, secondKey])
+    await ensureVariant(page, twoDir)
-  const third = await submit(project, `workspace two ${Date.now()}`)
+    const thirdState = await chooseDifferentVariant(page)
+    const third = await submit(page, `workspace two ${Date.now()}`)
+    trackSession(third, twoDir)
+    await waitUser(twoDir, third)
 
-  await goto(page, root, first)
+    await goto(page, root, first)
-  await waitFooter(page, firstState)
+    await waitFooter(page, firstState)
 
-  await goto(page, oneDir, second)
+    await goto(page, oneDir, second)
-  await waitFooter(page, secondState)
+    await waitFooter(page, secondState)
 
-  await goto(page, twoDir, third)
+    await goto(page, twoDir, third)
-  await waitFooter(page, thirdState)
+    await waitFooter(page, thirdState)
 
-  await goto(page, root, first)
+    await goto(page, root, first)
-  await waitFooter(page, firstState)
+    await waitFooter(page, firstState)
+  })
 })
 
-test("variant preserved when switching agent modes", async ({ page, project }) => {
+test("variant preserved when switching agent modes", async ({ page, withProject }) => {
   await page.setViewportSize({ width: 1440, height: 900 })
 
-  await project.open()
+  await withProject(async ({ directory, gotoSession }) => {
-  await project.gotoSession()
+    await gotoSession()
 
-  await ensureVariant(page, project.directory)
+    await ensureVariant(page, directory)
-  const updated = await chooseDifferentVariant(page)
+    const updated = await chooseDifferentVariant(page)
 
-  const available = await agents(page)
+    const available = await agents(page)
-  const other = available.find((name) => name !== updated.agent)
+    const other = available.find((name) => name !== updated.agent)
-  test.skip(!other, "only one agent available")
+    test.skip(!other, "only one agent available")
-  if (!other) return
+    if (!other) return
 
-  await choose(page, promptAgentSelector, other)
+    await choose(page, promptAgentSelector, other)
-  await waitFooter(page, { agent: other, variant: updated.variant })
+    await waitFooter(page, { agent: other, variant: updated.variant })
 
-  await choose(page, promptAgentSelector, updated.agent)
+    await choose(page, promptAgentSelector, updated.agent)
-  await waitFooter(page, { agent: updated.agent, variant: updated.variant })
+    await waitFooter(page, { agent: updated.agent, variant: updated.variant })
+  })
 })

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

@@ -1,6 +1,6 @@
 import { waitSessionIdle, withSession } from "../actions"
 import { test, expect } from "../fixtures"
-import { bodyText } from "../prompt/mock"
+import { createSdk } from "../utils"
 
 const count = 14
 
@@ -40,19 +40,8 @@ function edit(file: string, prev: string, next: string) {
   )
 }
 
-async function patchWithMock(
+async function patch(sdk: ReturnType<typeof createSdk>, sessionID: string, patchText: string) {
-  llm: Parameters<typeof test>[0]["llm"],
+  await sdk.session.promptAsync({
-  sdk: Parameters<typeof withSession>[0],
-  sessionID: string,
-  patchText: string,
-) {
-  const callsBefore = await llm.calls()
-  await llm.toolMatch(
-    (hit) => bodyText(hit).includes("Your only valid response is one apply_patch tool call."),
-    "apply_patch",
-    { patchText },
-  )
-  await sdk.session.prompt({
     sessionID,
     agent: "build",
     system: [
@@ -65,16 +54,7 @@ async function patchWithMock(
     parts: [{ type: "text", text: "Apply the provided patch exactly once." }],
   })
 
-  await expect.poll(() => llm.calls().then((c) => c > callsBefore), { timeout: 30_000 }).toBe(true)
+  await waitSessionIdle(sdk, sessionID, 120_000)
-  await expect
-    .poll(
-      async () => {
-        const diff = await sdk.session.diff({ sessionID }).then((res) => res.data ?? [])
-        return diff.length
-      },
-      { timeout: 120_000 },
-    )
-    .toBeGreaterThan(0)
 }
 
 async function show(page: Parameters<typeof test>[0]["page"]) {
@@ -253,7 +233,7 @@ async function fileOverflow(page: Parameters<typeof test>[0]["page"]) {
   }
 }
 
-test("review applies inline comment clicks without horizontal overflow", async ({ page, llm, project }) => {
+test("review applies inline comment clicks without horizontal overflow", async ({ page, withProject }) => {
   test.setTimeout(180_000)
 
   const tag = `review-comment-${Date.now()}`
@@ -262,45 +242,47 @@ test("review applies inline comment clicks without horizontal overflow", async (
 
   await page.setViewportSize({ width: 1280, height: 900 })
 
-  await project.open()
+  await withProject(async (project) => {
-  await withSession(project.sdk, `e2e review comment ${tag}`, async (session) => {
+    const sdk = createSdk(project.directory)
-    project.trackSession(session.id)
-    await patchWithMock(llm, project.sdk, session.id, seed([{ file, mark: tag }]))
 
-    await expect
+    await withSession(sdk, `e2e review comment ${tag}`, async (session) => {
-      .poll(
+      await patch(sdk, session.id, seed([{ file, mark: tag }]))
-        async () => {
-          const diff = await project.sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-          return diff.length
-        },
-        { timeout: 60_000 },
-      )
-      .toBe(1)
 
-    await project.gotoSession(session.id)
+      await expect
-    await show(page)
+        .poll(
+          async () => {
+            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
+            return diff.length
+          },
+          { timeout: 60_000 },
+        )
+        .toBe(1)
 
-    const tab = page.getByRole("tab", { name: /Review/i }).first()
+      await project.gotoSession(session.id)
-    await expect(tab).toBeVisible()
+      await show(page)
-    await tab.click()
 
-    await expand(page)
+      const tab = page.getByRole("tab", { name: /Review/i }).first()
-    await waitMark(page, file, tag)
+      await expect(tab).toBeVisible()
-    await comment(page, file, note)
+      await tab.click()
 
-    await expect
+      await expand(page)
-      .poll(async () => (await overflow(page, file))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+      await waitMark(page, file, tag)
-      .toBeLessThanOrEqual(1)
+      await comment(page, file, note)
-    await expect
+
-      .poll(async () => (await overflow(page, file))?.pop ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+      await expect
-      .toBeLessThanOrEqual(1)
+        .poll(async () => (await overflow(page, file))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-    await expect
+        .toBeLessThanOrEqual(1)
-      .poll(async () => (await overflow(page, file))?.tools ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+      await expect
-      .toBeLessThanOrEqual(1)
+        .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, llm, project }) => {
+test("review file comments submit on click without clipping actions", async ({ page, withProject }) => {
   test.setTimeout(180_000)
 
   const tag = `review-file-comment-${Date.now()}`
@@ -309,46 +291,49 @@ test("review file comments submit on click without clipping actions", async ({ p
 
   await page.setViewportSize({ width: 1280, height: 900 })
 
-  await project.open()
+  await withProject(async (project) => {
-  await withSession(project.sdk, `e2e review file comment ${tag}`, async (session) => {
+    const sdk = createSdk(project.directory)
-    project.trackSession(session.id)
-    await patchWithMock(llm, project.sdk, session.id, seed([{ file, mark: tag }]))
 
-    await expect
+    await withSession(sdk, `e2e review file comment ${tag}`, async (session) => {
-      .poll(
+      await patch(sdk, session.id, seed([{ file, mark: tag }]))
-        async () => {
-          const diff = await project.sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-          return diff.length
-        },
-        { timeout: 60_000 },
-      )
-      .toBe(1)
 
-    await project.gotoSession(session.id)
+      await expect
-    await show(page)
+        .poll(
+          async () => {
+            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
+            return diff.length
+          },
+          { timeout: 60_000 },
+        )
+        .toBe(1)
 
-    const tab = page.getByRole("tab", { name: /Review/i }).first()
+      await project.gotoSession(session.id)
-    await expect(tab).toBeVisible()
+      await show(page)
-    await tab.click()
 
-    await expand(page)
+      const tab = page.getByRole("tab", { name: /Review/i }).first()
-    await waitMark(page, file, tag)
+      await expect(tab).toBeVisible()
-    await openReviewFile(page, file)
+      await tab.click()
-    await fileComment(page, note)
 
-    await expect
+      await expand(page)
-      .poll(async () => (await fileOverflow(page))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+      await waitMark(page, file, tag)
-      .toBeLessThanOrEqual(1)
+      await openReviewFile(page, file)
-    await expect
+      await fileComment(page, note)
-      .poll(async () => (await fileOverflow(page))?.pop ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+
-      .toBeLessThanOrEqual(1)
+      await expect
-    await expect
+        .poll(async () => (await fileOverflow(page))?.width ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
-      .poll(async () => (await fileOverflow(page))?.tools ?? Number.POSITIVE_INFINITY, { timeout: 10_000 })
+        .toBeLessThanOrEqual(1)
-      .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.fixme("review keeps scroll position after a live diff update", async ({ page, llm, project }) => {
+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()}`
@@ -358,83 +343,84 @@ test.fixme("review keeps scroll position after a live diff update", async ({ pag
 
   await page.setViewportSize({ width: 1600, height: 1000 })
 
-  await project.open()
+  await withProject(async (project) => {
-  await withSession(project.sdk, `e2e review ${tag}`, async (session) => {
+    const sdk = createSdk(project.directory)
-    project.trackSession(session.id)
-    await patchWithMock(llm, project.sdk, session.id, seed(list))
 
-    await expect
+    await withSession(sdk, `e2e review ${tag}`, async (session) => {
-      .poll(
+      await patch(sdk, session.id, seed(list))
-        async () => {
-          const info = await project.sdk.session.get({ sessionID: session.id }).then((res) => res.data)
-          return info?.summary?.files ?? 0
-        },
-        { timeout: 60_000 },
-      )
-      .toBe(list.length)
 
-    await expect
+      await expect
-      .poll(
+        .poll(
-        async () => {
+          async () => {
-          const diff = await project.sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
+            const info = await sdk.session.get({ sessionID: session.id }).then((res) => res.data)
-          return diff.length
+            return info?.summary?.files ?? 0
-        },
+          },
-        { timeout: 60_000 },
+          { timeout: 60_000 },
-      )
+        )
-      .toBe(list.length)
+        .toBe(list.length)
 
-    await project.gotoSession(session.id)
+      await expect
-    await show(page)
+        .poll(
+          async () => {
+            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
+            return diff.length
+          },
+          { timeout: 60_000 },
+        )
+        .toBe(list.length)
 
-    const tab = page.getByRole("tab", { name: /Review/i }).first()
+      await project.gotoSession(session.id)
-    await expect(tab).toBeVisible()
+      await show(page)
-    await tab.click()
 
-    const view = page.locator('[data-slot="session-review-scroll"] .scroll-view__viewport').first()
+      const tab = page.getByRole("tab", { name: /Review/i }).first()
-    await expect(view).toBeVisible()
+      await expect(tab).toBeVisible()
-    const heads = page.getByRole("heading", { level: 3 }).filter({ hasText: /^review-scroll-/ })
+      await tab.click()
-    await expect(heads).toHaveCount(list.length, { timeout: 60_000 })
 
-    await expand(page)
+      const view = page.locator('[data-slot="session-review-scroll"] .scroll-view__viewport').first()
-    await waitMark(page, hit.file, hit.mark)
+      await expect(view).toBeVisible()
-
+      const heads = page.getByRole("heading", { level: 3 }).filter({ hasText: /^review-scroll-/ })
-    const row = page
+      await expect(heads).toHaveCount(list.length, {
-      .getByRole("heading", {
+        timeout: 60_000,
-        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)
+      await expand(page)
-    const prev = await spot(page, hit.file)
+      await waitMark(page, hit.file, hit.mark)
-    if (!prev) throw new Error(`missing review row for ${hit.file}`)
 
-    await patchWithMock(llm, project.sdk, session.id, edit(hit.file, hit.mark, next))
+      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
+      await expect.poll(async () => (await spot(page, hit.file))?.y ?? 0).toBeGreaterThan(200)
-      .poll(
+      const prev = await spot(page, hit.file)
-        async () => {
+      if (!prev) throw new Error(`missing review row for ${hit.file}`)
-          const diff = await project.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 patch(sdk, session.id, edit(hit.file, hit.mark, next))
 
-    await expect
+      await expect
-      .poll(
+        .poll(
-        async () => {
+          async () => {
-          const next = await spot(page, hit.file)
+            const diff = await sdk.session.diff({ sessionID: session.id }).then((res) => res.data ?? [])
-          if (!next) return Number.POSITIVE_INFINITY
+            const item = diff.find((item) => item.file === hit.file)
-          return Math.max(Math.abs(next.top - prev.top), Math.abs(next.y - prev.y))
+            return typeof item?.after === "string" ? item.after : ""
-        },
+          },
-        { timeout: 60_000 },
+          { timeout: 60_000 },
-      )
+        )
-      .toBeLessThanOrEqual(32)
+        .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

@@ -49,185 +49,185 @@ async function seedConversation(input: {
   return { prompt, userMessageID }
 }
 
-test("slash undo sets revert and restores prior prompt", async ({ page, project }) => {
+test("slash undo sets revert and restores prior prompt", async ({ page, withProject }) => {
   test.setTimeout(120_000)
 
   const token = `undo_${Date.now()}`
 
-  await project.open()
+  await withProject(async (project) => {
-  const sdk = project.sdk
+    const sdk = createSdk(project.directory)
 
-  await withSession(sdk, `e2e undo ${Date.now()}`, async (session) => {
+    await withSession(sdk, `e2e undo ${Date.now()}`, async (session) => {
-    project.trackSession(session.id)
+      await project.gotoSession(session.id)
-    await project.gotoSession(session.id)
 
-    const seeded = await seedConversation({ page, sdk, sessionID: session.id, token })
+      const seeded = await seedConversation({ page, sdk, sessionID: session.id, token })
 
-    await seeded.prompt.click()
+      await seeded.prompt.click()
-    await page.keyboard.type("/undo")
+      await page.keyboard.type("/undo")
 
-    const undo = page.locator('[data-slash-id="session.undo"]').first()
+      const undo = page.locator('[data-slash-id="session.undo"]').first()
-    await expect(undo).toBeVisible()
+      await expect(undo).toBeVisible()
-    await page.keyboard.press("Enter")
+      await page.keyboard.press("Enter")
 
-    await expect
+      await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
+          timeout: 30_000,
-      })
+        })
-      .toBe(seeded.userMessageID)
+        .toBe(seeded.userMessageID)
 
-    await expect(seeded.prompt).toContainText(token)
+      await expect(seeded.prompt).toContainText(token)
-    await expect(page.locator(`[data-message-id="${seeded.userMessageID}"]`)).toHaveCount(0)
+      await expect(page.locator(`[data-message-id="${seeded.userMessageID}"]`)).toHaveCount(0)
+    })
   })
 })
 
-test("slash redo clears revert and restores latest state", async ({ page, project }) => {
+test("slash redo clears revert and restores latest state", async ({ page, withProject }) => {
   test.setTimeout(120_000)
 
   const token = `redo_${Date.now()}`
 
-  await project.open()
+  await withProject(async (project) => {
-  const sdk = project.sdk
+    const sdk = createSdk(project.directory)
 
-  await withSession(sdk, `e2e redo ${Date.now()}`, async (session) => {
+    await withSession(sdk, `e2e redo ${Date.now()}`, async (session) => {
-    project.trackSession(session.id)
+      await project.gotoSession(session.id)
-    await project.gotoSession(session.id)
 
-    const seeded = await seedConversation({ page, sdk, sessionID: session.id, token })
+      const seeded = await seedConversation({ page, sdk, sessionID: session.id, token })
 
-    await seeded.prompt.click()
+      await seeded.prompt.click()
-    await page.keyboard.type("/undo")
+      await page.keyboard.type("/undo")
 
-    const undo = page.locator('[data-slash-id="session.undo"]').first()
+      const undo = page.locator('[data-slash-id="session.undo"]').first()
-    await expect(undo).toBeVisible()
+      await expect(undo).toBeVisible()
-    await page.keyboard.press("Enter")
+      await page.keyboard.press("Enter")
 
-    await expect
+      await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
+          timeout: 30_000,
-      })
+        })
-      .toBe(seeded.userMessageID)
+        .toBe(seeded.userMessageID)
 
-    await seeded.prompt.click()
+      await seeded.prompt.click()
-    await page.keyboard.press(`${modKey}+A`)
+      await page.keyboard.press(`${modKey}+A`)
-    await page.keyboard.press("Backspace")
+      await page.keyboard.press("Backspace")
-    await page.keyboard.type("/redo")
+      await page.keyboard.type("/redo")
 
-    const redo = page.locator('[data-slash-id="session.redo"]').first()
+      const redo = page.locator('[data-slash-id="session.redo"]').first()
-    await expect(redo).toBeVisible()
+      await expect(redo).toBeVisible()
-    await page.keyboard.press("Enter")
+      await page.keyboard.press("Enter")
 
-    await expect
+      await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
+          timeout: 30_000,
-      })
+        })
-      .toBeUndefined()
+        .toBeUndefined()
 
-    await expect(seeded.prompt).not.toContainText(token)
+      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}"]`)).toHaveCount(1)
+    })
   })
 })
 
-test("slash undo/redo traverses multi-step revert stack", async ({ page, project }) => {
+test("slash undo/redo traverses multi-step revert stack", async ({ page, withProject }) => {
   test.setTimeout(120_000)
 
   const firstToken = `undo_redo_first_${Date.now()}`
   const secondToken = `undo_redo_second_${Date.now()}`
 
-  await project.open()
+  await withProject(async (project) => {
-  const sdk = project.sdk
+    const sdk = createSdk(project.directory)
 
-  await withSession(sdk, `e2e undo redo stack ${Date.now()}`, async (session) => {
+    await withSession(sdk, `e2e undo redo stack ${Date.now()}`, async (session) => {
-    project.trackSession(session.id)
+      await project.gotoSession(session.id)
-    await project.gotoSession(session.id)
 
-    const first = await seedConversation({
+      const first = await seedConversation({
-      page,
+        page,
-      sdk,
+        sdk,
-      sessionID: session.id,
+        sessionID: session.id,
-      token: firstToken,
+        token: firstToken,
+      })
+      const second = await seedConversation({
+        page,
+        sdk,
+        sessionID: session.id,
+        token: secondToken,
+      })
+
+      expect(first.userMessageID).not.toBe(second.userMessageID)
+
+      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 second.prompt.click()
+      await page.keyboard.press(`${modKey}+A`)
+      await page.keyboard.press("Backspace")
+      await page.keyboard.type("/undo")
+
+      const undo = page.locator('[data-slash-id="session.undo"]').first()
+      await expect(undo).toBeVisible()
+      await page.keyboard.press("Enter")
+
+      await expect
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+          timeout: 30_000,
+        })
+        .toBe(second.userMessageID)
+
+      await expect(firstMessage).toHaveCount(1)
+      await expect(secondMessage).toHaveCount(0)
+
+      await second.prompt.click()
+      await page.keyboard.press(`${modKey}+A`)
+      await page.keyboard.press("Backspace")
+      await page.keyboard.type("/undo")
+      await expect(undo).toBeVisible()
+      await page.keyboard.press("Enter")
+
+      await expect
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+          timeout: 30_000,
+        })
+        .toBe(first.userMessageID)
+
+      await expect(firstMessage).toHaveCount(0)
+      await expect(secondMessage).toHaveCount(0)
+
+      await second.prompt.click()
+      await page.keyboard.press(`${modKey}+A`)
+      await page.keyboard.press("Backspace")
+      await page.keyboard.type("/redo")
+
+      const redo = page.locator('[data-slash-id="session.redo"]').first()
+      await expect(redo).toBeVisible()
+      await page.keyboard.press("Enter")
+
+      await expect
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+          timeout: 30_000,
+        })
+        .toBe(second.userMessageID)
+
+      await expect(firstMessage).toHaveCount(1)
+      await expect(secondMessage).toHaveCount(0)
+
+      await second.prompt.click()
+      await page.keyboard.press(`${modKey}+A`)
+      await page.keyboard.press("Backspace")
+      await page.keyboard.type("/redo")
+      await expect(redo).toBeVisible()
+      await page.keyboard.press("Enter")
+
+      await expect
+        .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
+          timeout: 30_000,
+        })
+        .toBeUndefined()
+
+      await expect(firstMessage).toHaveCount(1)
+      await expect(secondMessage).toHaveCount(1)
     })
-    const second = await seedConversation({
-      page,
-      sdk,
-      sessionID: session.id,
-      token: secondToken,
-    })
-
-    expect(first.userMessageID).not.toBe(second.userMessageID)
-
-    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 second.prompt.click()
-    await page.keyboard.press(`${modKey}+A`)
-    await page.keyboard.press("Backspace")
-    await page.keyboard.type("/undo")
-
-    const undo = page.locator('[data-slash-id="session.undo"]').first()
-    await expect(undo).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
-      })
-      .toBe(second.userMessageID)
-
-    await expect(firstMessage).toHaveCount(1)
-    await expect(secondMessage).toHaveCount(0)
-
-    await second.prompt.click()
-    await page.keyboard.press(`${modKey}+A`)
-    await page.keyboard.press("Backspace")
-    await page.keyboard.type("/undo")
-    await expect(undo).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
-      })
-      .toBe(first.userMessageID)
-
-    await expect(firstMessage).toHaveCount(0)
-    await expect(secondMessage).toHaveCount(0)
-
-    await second.prompt.click()
-    await page.keyboard.press(`${modKey}+A`)
-    await page.keyboard.press("Backspace")
-    await page.keyboard.type("/redo")
-
-    const redo = page.locator('[data-slash-id="session.redo"]').first()
-    await expect(redo).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
-      })
-      .toBe(second.userMessageID)
-
-    await expect(firstMessage).toHaveCount(1)
-    await expect(secondMessage).toHaveCount(0)
-
-    await second.prompt.click()
-    await page.keyboard.press(`${modKey}+A`)
-    await page.keyboard.press("Backspace")
-    await page.keyboard.type("/redo")
-    await expect(redo).toBeVisible()
-    await page.keyboard.press("Enter")
-
-    await expect
-      .poll(async () => await sdk.session.get({ sessionID: session.id }).then((r) => r.data?.revert?.messageID), {
-        timeout: 30_000,
-      })
-      .toBeUndefined()
-
-    await expect(firstMessage).toHaveCount(1)
-    await expect(secondMessage).toHaveCount(1)
   })
 })

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

@@ -31,16 +31,14 @@ async function seedMessage(sdk: Sdk, sessionID: string) {
     .toBeGreaterThan(0)
 }
 
-test("session can be renamed via header menu", async ({ page, project }) => {
+test("session can be renamed via header menu", async ({ page, sdk, gotoSession }) => {
   const stamp = Date.now()
   const originalTitle = `e2e rename test ${stamp}`
   const renamedTitle = `e2e renamed ${stamp}`
 
-  await project.open()
+  await withSession(sdk, originalTitle, async (session) => {
-  await withSession(project.sdk, originalTitle, async (session) => {
+    await seedMessage(sdk, session.id)
-    project.trackSession(session.id)
+    await gotoSession(session.id)
-    await seedMessage(project.sdk, session.id)
-    await project.gotoSession(session.id)
     await expect(page.getByRole("heading", { level: 1 }).first()).toHaveText(originalTitle)
 
     const menu = await openSessionMoreMenu(page, session.id)
@@ -56,7 +54,7 @@ test("session can be renamed via header menu", async ({ page, project }) => {
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.title
         },
         { timeout: 30_000 },
@@ -67,22 +65,20 @@ test("session can be renamed via header menu", async ({ page, project }) => {
   })
 })
 
-test("session can be archived via header menu", async ({ page, project }) => {
+test("session can be archived via header menu", async ({ page, sdk, gotoSession }) => {
   const stamp = Date.now()
   const title = `e2e archive test ${stamp}`
 
-  await project.open()
+  await withSession(sdk, title, async (session) => {
-  await withSession(project.sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
-    project.trackSession(session.id)
+    await gotoSession(session.id)
-    await seedMessage(project.sdk, session.id)
-    await project.gotoSession(session.id)
     const menu = await openSessionMoreMenu(page, session.id)
     await clickMenuItem(menu, /archive/i)
 
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.time?.archived
         },
         { timeout: 30_000 },
@@ -94,15 +90,13 @@ test("session can be archived via header menu", async ({ page, project }) => {
   })
 })
 
-test("session can be deleted via header menu", async ({ page, project }) => {
+test("session can be deleted via header menu", async ({ page, sdk, gotoSession }) => {
   const stamp = Date.now()
   const title = `e2e delete test ${stamp}`
 
-  await project.open()
+  await withSession(sdk, title, async (session) => {
-  await withSession(project.sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
-    project.trackSession(session.id)
+    await gotoSession(session.id)
-    await seedMessage(project.sdk, session.id)
-    await project.gotoSession(session.id)
     const menu = await openSessionMoreMenu(page, session.id)
     await clickMenuItem(menu, /delete/i)
     await confirmDialog(page, /delete/i)
@@ -110,7 +104,7 @@ test("session can be deleted via header menu", async ({ page, project }) => {
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session
+          const data = await sdk.session
             .get({ sessionID: session.id })
             .then((r) => r.data)
             .catch(() => undefined)
@@ -125,17 +119,15 @@ test("session can be deleted via header menu", async ({ page, project }) => {
   })
 })
 
-test("session can be shared and unshared via header button", async ({ page, project }) => {
+test("session can be shared and unshared via header button", async ({ page, sdk, gotoSession }) => {
   test.skip(shareDisabled, "Share is disabled in this environment (OPENCODE_DISABLE_SHARE).")
 
   const stamp = Date.now()
   const title = `e2e share test ${stamp}`
 
-  await project.open()
+  await withSession(sdk, title, async (session) => {
-  await withSession(project.sdk, title, async (session) => {
+    await seedMessage(sdk, session.id)
-    project.trackSession(session.id)
+    await gotoSession(session.id)
-    await project.gotoSession(session.id)
-    await project.prompt(`share seed ${stamp}`)
 
     const shared = await openSharePopover(page)
     const publish = shared.popoverBody.getByRole("button", { name: "Publish" }).first()
@@ -149,7 +141,7 @@ test("session can be shared and unshared via header button", async ({ page, proj
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.share?.url || undefined
         },
         { timeout: 30_000 },
@@ -167,7 +159,7 @@ test("session can be shared and unshared via header button", async ({ page, proj
     await expect
       .poll(
         async () => {
-          const data = await project.sdk.session.get({ sessionID: session.id }).then((r) => r.data)
+          const data = await sdk.session.get({ sessionID: session.id }).then((r) => r.data)
           return data?.share?.url || undefined
         },
         { timeout: 30_000 },

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

@@ -241,7 +241,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)

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

@@ -2,7 +2,7 @@ import { test, expect, settingsKey } from "../fixtures"
 import { closeDialog, openSettings } from "../actions"
 import {
   settingsColorSchemeSelector,
-  settingsCodeFontSelector,
+  settingsFontSelector,
   settingsLanguageSelectSelector,
   settingsNotificationsAgentSelector,
   settingsNotificationsErrorsSelector,
@@ -12,7 +12,6 @@ import {
   settingsSoundsErrorsSelector,
   settingsSoundsPermissionsSelector,
   settingsThemeSelector,
-  settingsUIFontSelector,
   settingsUpdatesStartupSelector,
 } from "../selectors"
 
@@ -88,20 +87,10 @@ test("changing theme persists in localStorage", async ({ page, gotoSession }) =>
     return document.documentElement.getAttribute("data-theme")
   })
   const currentTheme = (await select.locator('[data-slot="select-select-trigger-value"]').textContent())?.trim() ?? ""
-  const trigger = select.locator('[data-slot="select-select-trigger"]')
-  const items = page.locator('[data-slot="select-select-item"]')
 
-  await trigger.click()
+  await select.locator('[data-slot="select-select-trigger"]').click()
-  const open = await expect
+
-    .poll(async () => (await items.count()) > 0, { timeout: 5_000 })
+  const items = page.locator('[data-slot="select-select-item"]')
-    .toBe(true)
-    .then(() => true)
-    .catch(() => false)
-  if (!open) {
-    await trigger.click()
-    await expect.poll(async () => (await items.count()) > 0, { timeout: 10_000 }).toBe(true)
-  }
-  await expect(items.first()).toBeVisible()
   const count = await items.count()
   expect(count).toBeGreaterThan(1)
 
@@ -163,199 +152,39 @@ test("legacy oc-1 theme migrates to oc-2", async ({ page, gotoSession }) => {
     .toBeNull()
 })
 
-test("typing a code font with spaces persists and updates CSS variable", async ({ page, gotoSession }) => {
+test("changing font persists in localStorage and updates CSS variable", async ({ page, gotoSession }) => {
   await gotoSession()
 
   const dialog = await openSettings(page)
-  const input = dialog.locator(settingsCodeFontSelector)
+  const select = dialog.locator(settingsFontSelector)
-  await expect(input).toBeVisible()
+  await expect(select).toBeVisible()
-  await expect(input).toHaveAttribute("placeholder", "System Mono")
 
-  const initialFontFamily = await page.evaluate(() =>
+  const initialFontFamily = await page.evaluate(() => {
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
+    return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono")
-  )
+  })
-  const initialUIFamily = await page.evaluate(() =>
+  expect(initialFontFamily).toContain("IBM Plex Mono")
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
-  expect(initialFontFamily).toContain("ui-monospace")
 
-  const next = "Test Mono"
+  await select.locator('[data-slot="select-select-trigger"]').click()
 
-  await input.click()
+  const items = page.locator('[data-slot="select-select-item"]')
-  await input.clear()
+  await items.nth(2).click()
-  await input.pressSequentially(next)
-  await expect(input).toHaveValue(next)
 
-  await expect
+  await page.waitForTimeout(100)
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        mono: next,
-      },
-    })
 
-  const newFontFamily = await page.evaluate(() =>
+  const stored = await page.evaluate((key) => {
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
+    const raw = localStorage.getItem(key)
-  )
+    return raw ? JSON.parse(raw) : null
-  const newUIFamily = await page.evaluate(() =>
+  }, settingsKey)
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
+
-  )
+  expect(stored?.appearance?.font).not.toBe("ibm-plex-mono")
-  expect(newFontFamily).toContain(next)
+
+  const newFontFamily = await page.evaluate(() => {
+    return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono")
+  })
   expect(newFontFamily).not.toBe(initialFontFamily)
-  expect(newUIFamily).toBe(initialUIFamily)
 })
 
-test("typing a UI font with spaces persists and updates CSS variable", async ({ page, gotoSession }) => {
+test("color scheme and font rehydrate after reload", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const dialog = await openSettings(page)
-  const input = dialog.locator(settingsUIFontSelector)
-  await expect(input).toBeVisible()
-  await expect(input).toHaveAttribute("placeholder", "System Sans")
-
-  const initialFontFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
-  const initialCodeFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
-  )
-  expect(initialFontFamily).toContain("ui-sans-serif")
-
-  const next = "Test Sans"
-
-  await input.click()
-  await input.clear()
-  await input.pressSequentially(next)
-  await expect(input).toHaveValue(next)
-
-  await expect
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        sans: next,
-      },
-    })
-
-  const newFontFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
-  const newCodeFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
-  )
-  expect(newFontFamily).toContain(next)
-  expect(newFontFamily).not.toBe(initialFontFamily)
-  expect(newCodeFamily).toBe(initialCodeFamily)
-})
-
-test("clearing the code font field restores the default placeholder and stack", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const dialog = await openSettings(page)
-  const input = dialog.locator(settingsCodeFontSelector)
-  await expect(input).toBeVisible()
-
-  await input.click()
-  await input.clear()
-  await input.pressSequentially("Reset Mono")
-
-  await expect
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        mono: "Reset Mono",
-      },
-    })
-
-  await input.clear()
-  await input.press("Space")
-  await expect(input).toHaveValue("")
-  await expect(input).toHaveAttribute("placeholder", "System Mono")
-
-  await expect
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        mono: "",
-      },
-    })
-
-  const fontFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
-  )
-  expect(fontFamily).toContain("ui-monospace")
-  expect(fontFamily).not.toContain("Reset Mono")
-})
-
-test("clearing the UI font field restores the default placeholder and stack", async ({ page, gotoSession }) => {
-  await gotoSession()
-
-  const dialog = await openSettings(page)
-  const input = dialog.locator(settingsUIFontSelector)
-  await expect(input).toBeVisible()
-
-  await input.click()
-  await input.clear()
-  await input.pressSequentially("Reset Sans")
-
-  await expect
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        sans: "Reset Sans",
-      },
-    })
-
-  await input.clear()
-  await input.press("Space")
-  await expect(input).toHaveValue("")
-  await expect(input).toHaveAttribute("placeholder", "System Sans")
-
-  await expect
-    .poll(async () => {
-      return await page.evaluate((key) => {
-        const raw = localStorage.getItem(key)
-        return raw ? JSON.parse(raw) : null
-      }, settingsKey)
-    })
-    .toMatchObject({
-      appearance: {
-        sans: "",
-      },
-    })
-
-  const fontFamily = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
-  expect(fontFamily).toContain("ui-sans-serif")
-  expect(fontFamily).not.toContain("Reset Sans")
-})
-
-test("color scheme, code font, and UI font rehydrate after reload", async ({ page, gotoSession }) => {
   await gotoSession()
 
   const dialog = await openSettings(page)
@@ -366,35 +195,31 @@ test("color scheme, code font, and UI font rehydrate after reload", async ({ pag
   await page.locator('[data-slot="select-select-item"]').filter({ hasText: "Dark" }).click()
   await expect(page.locator("html")).toHaveAttribute("data-color-scheme", "dark")
 
-  const code = dialog.locator(settingsCodeFontSelector)
+  const fontSelect = dialog.locator(settingsFontSelector)
-  const ui = dialog.locator(settingsUIFontSelector)
+  await expect(fontSelect).toBeVisible()
-  await expect(code).toBeVisible()
-  await expect(ui).toBeVisible()
 
-  const initialMono = await page.evaluate(() =>
+  const initialFontFamily = await page.evaluate(() => {
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
+    return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim()
-  )
+  })
-  const initialSans = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
 
   const initialSettings = await page.evaluate((key) => {
     const raw = localStorage.getItem(key)
     return raw ? JSON.parse(raw) : null
   }, settingsKey)
 
-  const mono = initialSettings?.appearance?.mono === "Reload Mono" ? "Reload Mono 2" : "Reload Mono"
+  const currentFont =
-  const sans = initialSettings?.appearance?.sans === "Reload Sans" ? "Reload Sans 2" : "Reload Sans"
+    (await fontSelect.locator('[data-slot="select-select-trigger-value"]').textContent())?.trim() ?? ""
+  await fontSelect.locator('[data-slot="select-select-trigger"]').click()
 
-  await code.click()
+  const fontItems = page.locator('[data-slot="select-select-item"]')
-  await code.clear()
+  expect(await fontItems.count()).toBeGreaterThan(1)
-  await code.pressSequentially(mono)
-  await expect(code).toHaveValue(mono)
 
-  await ui.click()
+  if (currentFont) {
-  await ui.clear()
+    await fontItems.filter({ hasNotText: currentFont }).first().click()
-  await ui.pressSequentially(sans)
+  }
-  await expect(ui).toHaveValue(sans)
+  if (!currentFont) {
+    await fontItems.nth(1).click()
+  }
 
   await expect
     .poll(async () => {
@@ -405,8 +230,7 @@ test("color scheme, code font, and UI font rehydrate after reload", async ({ pag
     })
     .toMatchObject({
       appearance: {
-        mono,
+        font: expect.any(String),
-        sans,
       },
     })
 
@@ -415,18 +239,11 @@ test("color scheme, code font, and UI font rehydrate after reload", async ({ pag
     return raw ? JSON.parse(raw) : null
   }, settingsKey)
 
-  const updatedMono = await page.evaluate(() =>
+  const updatedFontFamily = await page.evaluate(() => {
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
+    return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim()
-  )
+  })
-  const updatedSans = await page.evaluate(() =>
+  expect(updatedFontFamily).not.toBe(initialFontFamily)
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
+  expect(updatedSettings?.appearance?.font).not.toBe(initialSettings?.appearance?.font)
-  )
-  expect(updatedMono).toContain(mono)
-  expect(updatedMono).not.toBe(initialMono)
-  expect(updatedSans).toContain(sans)
-  expect(updatedSans).not.toBe(initialSans)
-  expect(updatedSettings?.appearance?.mono).toBe(mono)
-  expect(updatedSettings?.appearance?.sans).toBe(sans)
 
   await closeDialog(page, dialog)
   await page.reload()
@@ -442,8 +259,7 @@ test("color scheme, code font, and UI font rehydrate after reload", async ({ pag
     })
     .toMatchObject({
       appearance: {
-        mono,
+        font: updatedSettings?.appearance?.font,
-        sans,
       },
     })
 
@@ -454,32 +270,17 @@ test("color scheme, code font, and UI font rehydrate after reload", async ({ pag
 
   await expect
     .poll(async () => {
-      return await page.evaluate(() =>
+      return await page.evaluate(() => {
-        getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
+        return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim()
-      )
+      })
     })
-    .toContain(mono)
+    .not.toBe(initialFontFamily)
 
-  await expect
+  const rehydratedFontFamily = await page.evaluate(() => {
-    .poll(async () => {
+    return getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim()
-      return await page.evaluate(() =>
+  })
-        getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
+  expect(rehydratedFontFamily).not.toBe(initialFontFamily)
-      )
+  expect(rehydratedSettings?.appearance?.font).toBe(updatedSettings?.appearance?.font)
-    })
-    .toContain(sans)
-
-  const rehydratedMono = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-mono").trim(),
-  )
-  const rehydratedSans = await page.evaluate(() =>
-    getComputedStyle(document.documentElement).getPropertyValue("--font-family-sans").trim(),
-  )
-  expect(rehydratedMono).toContain(mono)
-  expect(rehydratedMono).not.toBe(initialMono)
-  expect(rehydratedSans).toContain(sans)
-  expect(rehydratedSans).not.toBe(initialSans)
-  expect(rehydratedSettings?.appearance?.mono).toBe(mono)
-  expect(rehydratedSettings?.appearance?.sans).toBe(sans)
 })
 
 test("toggling notification agent switch updates localStorage", async ({ page, gotoSession }) => {

packages/app/e2e/sidebar/sidebar-popover-actions.spec.ts

@@ -1,16 +1,6 @@
 import { test, expect } from "../fixtures"
-import {
+import { cleanupSession, closeSidebar, hoverSessionItem } from "../actions"
-  defocus,
-  cleanupSession,
-  cleanupTestProject,
-  closeSidebar,
-  createTestProject,
-  hoverSessionItem,
-  openSidebar,
-  waitSession,
-} from "../actions"
 import { projectSwitchSelector } from "../selectors"
-import { dirSlug } from "../utils"
 
 test("collapsed sidebar popover stays open when archiving a session", async ({ page, slug, sdk, gotoSession }) => {
   const stamp = Date.now()
@@ -47,63 +37,3 @@ test("collapsed sidebar popover stays open when archiving a session", async ({ p
     await cleanupSession({ sdk, sessionID: two.id })
   }
 })
-
-test("open sidebar project popover stays closed after clicking avatar", async ({ page, project }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-
-  const other = await createTestProject()
-  const slug = dirSlug(other)
-
-  try {
-    await project.open({ extra: [other] })
-    await openSidebar(page)
-
-    const projectButton = page.locator(projectSwitchSelector(slug)).first()
-    const card = page.locator('[data-component="hover-card-content"]')
-
-    await expect(projectButton).toBeVisible()
-    await projectButton.hover()
-    await expect(card.getByText(/recent sessions/i)).toBeVisible()
-
-    await projectButton.click()
-    await expect(card).toHaveCount(0)
-
-    await waitSession(page, { directory: other })
-    await expect(card).toHaveCount(0)
-  } finally {
-    await cleanupTestProject(other)
-  }
-})
-
-test("open sidebar project switch activates on first tabbed enter", async ({ page, project }) => {
-  await page.setViewportSize({ width: 1400, height: 800 })
-
-  const other = await createTestProject()
-  const slug = dirSlug(other)
-
-  try {
-    await project.open({ extra: [other] })
-    await openSidebar(page)
-    await defocus(page)
-
-    const projectButton = page.locator(projectSwitchSelector(slug)).first()
-
-    await expect(projectButton).toBeVisible()
-
-    let hit = false
-    for (let i = 0; i < 20; i++) {
-      hit = await projectButton.evaluate((el) => {
-        return el.matches(":focus") || !!el.parentElement?.matches(":focus")
-      })
-      if (hit) break
-      await page.keyboard.press("Tab")
-    }
-
-    expect(hit).toBe(true)
-
-    await page.keyboard.press("Enter")
-    await waitSession(page, { directory: other })
-  } finally {
-    await cleanupTestProject(other)
-  }
-})

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

@@ -12,34 +12,35 @@ async function open(page: Page) {
   return term
 }
 
-test("terminal reconnects without replacing the pty", async ({ page, project }) => {
+test("terminal reconnects without replacing the pty", async ({ page, withProject }) => {
-  await project.open()
+  await withProject(async ({ gotoSession }) => {
-  const name = `OPENCODE_E2E_RECONNECT_${Date.now()}`
+    const name = `OPENCODE_E2E_RECONNECT_${Date.now()}`
-  const token = `E2E_RECONNECT_${Date.now()}`
+    const token = `E2E_RECONNECT_${Date.now()}`
 
-  await project.gotoSession()
+    await gotoSession()
 
-  const term = await open(page)
+    const term = await open(page)
-  const id = await term.getAttribute("data-pty-id")
+    const id = await term.getAttribute("data-pty-id")
-  if (!id) throw new Error("Active terminal missing data-pty-id")
+    if (!id) throw new Error("Active terminal missing data-pty-id")
 
-  const prev = await terminalConnects(page, { term })
+    const prev = await terminalConnects(page, { term })
 
-  await runTerminal(page, {
+    await runTerminal(page, {
-    term,
+      term,
-    cmd: `export ${name}=${token}; echo ${token}`,
+      cmd: `export ${name}=${token}; echo ${token}`,
-    token,
+      token,
-  })
+    })
 
-  await disconnectTerminal(page, { term })
+    await disconnectTerminal(page, { term })
 
-  await expect.poll(() => terminalConnects(page, { term }), { timeout: 15_000 }).toBeGreaterThan(prev)
+    await expect.poll(() => terminalConnects(page, { term }), { timeout: 15_000 }).toBeGreaterThan(prev)
-  await expect.poll(() => term.getAttribute("data-pty-id"), { timeout: 5_000 }).toBe(id)
+    await expect.poll(() => term.getAttribute("data-pty-id"), { timeout: 5_000 }).toBe(id)
 
-  await runTerminal(page, {
+    await runTerminal(page, {
-    term,
+      term,
-    cmd: `echo $${name}`,
+      cmd: `echo $${name}`,
-    token,
+      token,
-    timeout: 15_000,
+      timeout: 15_000,
+    })
   })
 })

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

@@ -1,7 +1,7 @@
 import type { Page } from "@playwright/test"
 import { runTerminal, waitTerminalReady } from "../actions"
 import { test, expect } from "../fixtures"
-import { dropdownMenuContentSelector, terminalSelector } from "../selectors"
+import { terminalSelector } from "../selectors"
 import { terminalToggleKey, workspacePersistKey } from "../utils"
 
 type State = {
@@ -36,130 +36,97 @@ async function store(page: Page, key: string) {
   }, key)
 }
 
-test("inactive terminal tab buffers persist across tab switches", async ({ page, project }) => {
+test("inactive terminal tab buffers persist across tab switches", async ({ page, withProject }) => {
-  await project.open()
+  await withProject(async ({ directory, gotoSession }) => {
-  const key = workspacePersistKey(project.directory, "terminal")
+    const key = workspacePersistKey(directory, "terminal")
-  const one = `E2E_TERM_ONE_${Date.now()}`
+    const one = `E2E_TERM_ONE_${Date.now()}`
-  const two = `E2E_TERM_TWO_${Date.now()}`
+    const two = `E2E_TERM_TWO_${Date.now()}`
-  const tabs = page.locator('#terminal-panel [data-slot="tabs-trigger"]')
+    const tabs = page.locator('#terminal-panel [data-slot="tabs-trigger"]')
-  const first = tabs.filter({ hasText: /Terminal 1/ }).first()
+    const first = tabs.filter({ hasText: /Terminal 1/ }).first()
-  const second = tabs.filter({ hasText: /Terminal 2/ }).first()
+    const second = tabs.filter({ hasText: /Terminal 2/ }).first()
 
-  await project.gotoSession()
+    await gotoSession()
-  await open(page)
+    await open(page)
 
-  await runTerminal(page, { cmd: `echo ${one}`, token: one })
+    await runTerminal(page, { cmd: `echo ${one}`, token: one })
 
-  await page.getByRole("button", { name: /new terminal/i }).click()
+    await page.getByRole("button", { name: /new terminal/i }).click()
-  await expect(tabs).toHaveCount(2)
+    await expect(tabs).toHaveCount(2)
 
-  await runTerminal(page, { cmd: `echo ${two}`, token: two })
+    await runTerminal(page, { cmd: `echo ${two}`, token: two })
 
-  await first.click()
+    await first.click()
-  await expect(first).toHaveAttribute("aria-selected", "true")
+    await expect(first).toHaveAttribute("aria-selected", "true")
 
-  await expect
+    await expect
-    .poll(
+      .poll(
-      async () => {
+        async () => {
-        const state = await store(page, key)
+          const state = await store(page, key)
-        const first = state?.all.find((item) => item.titleNumber === 1)?.buffer ?? ""
+          const first = state?.all.find((item) => item.titleNumber === 1)?.buffer ?? ""
-        const second = state?.all.find((item) => item.titleNumber === 2)?.buffer ?? ""
+          const second = state?.all.find((item) => item.titleNumber === 2)?.buffer ?? ""
-        return {
+          return {
-          first: first.includes(one),
+            first: first.includes(one),
-          second: second.includes(two),
+            second: second.includes(two),
-        }
+          }
-      },
+        },
-      { timeout: 5_000 },
+        { timeout: 5_000 },
-    )
+      )
-    .toEqual({ first: false, second: true })
+      .toEqual({ first: false, second: true })
 
-  await second.click()
+    await second.click()
-  await expect(second).toHaveAttribute("aria-selected", "true")
+    await expect(second).toHaveAttribute("aria-selected", "true")
-  await expect
+    await expect
-    .poll(
+      .poll(
-      async () => {
+        async () => {
-        const state = await store(page, key)
+          const state = await store(page, key)
-        const first = state?.all.find((item) => item.titleNumber === 1)?.buffer ?? ""
+          const first = state?.all.find((item) => item.titleNumber === 1)?.buffer ?? ""
-        const second = state?.all.find((item) => item.titleNumber === 2)?.buffer ?? ""
+          const second = state?.all.find((item) => item.titleNumber === 2)?.buffer ?? ""
-        return {
+          return {
-          first: first.includes(one),
+            first: first.includes(one),
-          second: second.includes(two),
+            second: second.includes(two),
-        }
+          }
-      },
+        },
-      { timeout: 5_000 },
+        { timeout: 5_000 },
-    )
+      )
-    .toEqual({ first: true, second: false })
+      .toEqual({ first: true, second: false })
+  })
 })
 
-test("closing the active terminal tab falls back to the previous tab", async ({ page, project }) => {
+test("closing the active terminal tab falls back to the previous tab", async ({ page, withProject }) => {
-  await project.open()
+  await withProject(async ({ directory, gotoSession }) => {
-  const key = workspacePersistKey(project.directory, "terminal")
+    const key = workspacePersistKey(directory, "terminal")
-  const tabs = page.locator('#terminal-panel [data-slot="tabs-trigger"]')
+    const tabs = page.locator('#terminal-panel [data-slot="tabs-trigger"]')
 
-  await project.gotoSession()
+    await gotoSession()
-  await open(page)
+    await open(page)
 
-  await page.getByRole("button", { name: /new terminal/i }).click()
+    await page.getByRole("button", { name: /new terminal/i }).click()
-  await expect(tabs).toHaveCount(2)
+    await expect(tabs).toHaveCount(2)
 
-  const second = tabs.filter({ hasText: /Terminal 2/ }).first()
+    const second = tabs.filter({ hasText: /Terminal 2/ }).first()
-  await second.click()
+    await second.click()
-  await expect(second).toHaveAttribute("aria-selected", "true")
+    await expect(second).toHaveAttribute("aria-selected", "true")
 
-  await second.hover()
+    await second.hover()
-  await page
+    await page
-    .getByRole("button", { name: /close terminal/i })
+      .getByRole("button", { name: /close terminal/i })
-    .nth(1)
+      .nth(1)
-    .click({ force: true })
+      .click({ force: true })
 
-  const first = tabs.filter({ hasText: /Terminal 1/ }).first()
+    const first = tabs.filter({ hasText: /Terminal 1/ }).first()
-  await expect(tabs).toHaveCount(1)
+    await expect(tabs).toHaveCount(1)
-  await expect(first).toHaveAttribute("aria-selected", "true")
+    await expect(first).toHaveAttribute("aria-selected", "true")
-  await expect
+    await expect
-    .poll(
+      .poll(
-      async () => {
+        async () => {
-        const state = await store(page, key)
+          const state = await store(page, key)
-        return {
+          return {
-          count: state?.all.length ?? 0,
+            count: state?.all.length ?? 0,
-          first: state?.all.some((item) => item.titleNumber === 1) ?? false,
+            first: state?.all.some((item) => item.titleNumber === 1) ?? false,
-        }
+          }
-      },
+        },
-      { timeout: 15_000 },
+        { timeout: 15_000 },
-    )
+      )
-    .toEqual({ count: 1, first: true })
+      .toEqual({ count: 1, first: true })
-})
+  })
-
-test("terminal tab can be renamed from the context menu", async ({ page, project }) => {
-  await project.open()
-  const key = workspacePersistKey(project.directory, "terminal")
-  const rename = `E2E term ${Date.now()}`
-  const tab = page.locator('#terminal-panel [data-slot="tabs-trigger"]').first()
-
-  await project.gotoSession()
-  await open(page)
-
-  await expect(tab).toContainText(/Terminal 1/)
-  await tab.click({ button: "right" })
-
-  const menu = page.locator(dropdownMenuContentSelector).first()
-  await expect(menu).toBeVisible()
-  await menu.getByRole("menuitem", { name: /^Rename$/i }).click()
-  await expect(menu).toHaveCount(0)
-
-  const input = page.locator('#terminal-panel input[type="text"]').first()
-  await expect(input).toBeVisible()
-  await input.fill(rename)
-  await input.press("Enter")
-
-  await expect(input).toHaveCount(0)
-  await expect(tab).toContainText(rename)
-  await expect
-    .poll(
-      async () => {
-        const state = await store(page, key)
-        return state?.all[0]?.title
-      },
-      { timeout: 5_000 },
-    )
-    .toBe(rename)
 })

packages/app/e2e/utils.ts

@@ -26,21 +26,21 @@ export const serverNamePattern = new RegExp(`(?:${serverNames.map(escape).join("
 export const modKey = process.platform === "darwin" ? "Meta" : "Control"
 export const terminalToggleKey = "Control+Backquote"
 
-export function createSdk(directory?: string, baseUrl = serverUrl) {
+export function createSdk(directory?: string) {
-  return createOpencodeClient({ baseUrl, directory, throwOnError: true })
+  return createOpencodeClient({ baseUrl: serverUrl, directory, throwOnError: true })
 }
 
-export async function resolveDirectory(directory: string, baseUrl = serverUrl) {
+export async function resolveDirectory(directory: string) {
-  return createSdk(directory, baseUrl)
+  return createSdk(directory)
     .path.get()
     .then((x) => x.data?.directory ?? directory)
 }
 
-export async function getWorktree(baseUrl = serverUrl) {
+export async function getWorktree() {
-  const sdk = createSdk(undefined, baseUrl)
+  const sdk = createSdk()
   const result = await sdk.path.get()
   const data = result.data
-  if (!data?.worktree) throw new Error(`Failed to resolve a worktree from ${baseUrl}/path`)
+  if (!data?.worktree) throw new Error(`Failed to resolve a worktree from ${serverUrl}/path`)
   return data.worktree
 }
 

packages/app/index.html

@@ -2,7 +2,7 @@
 <html lang="en" style="background-color: var(--background-base)">
   <head>
     <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, interactive-widget=resizes-content" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>OpenCode</title>
     <link rel="icon" type="image/png" href="/favicon-96x96-v3.png" sizes="96x96" />
     <link rel="icon" type="image/svg+xml" href="/favicon-v3.svg" />

packages/app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode-ai/app",
-  "version": "1.4.3",
+  "version": "1.2.27",
   "description": "",
   "type": "module",
   "exports": {
@@ -15,7 +15,6 @@
     "build": "vite build",
     "serve": "vite preview",
     "test": "bun run test:unit",
-    "test:ci": "mkdir -p .artifacts/unit && bun test --preload ./happydom.ts ./src --reporter=junit --reporter-outfile=.artifacts/unit/junit.xml",
     "test:unit": "bun test --preload ./happydom.ts ./src",
     "test:unit:watch": "bun test --watch --preload ./happydom.ts ./src",
     "test:e2e": "playwright test",
@@ -47,17 +46,14 @@
     "@solid-primitives/active-element": "2.1.3",
     "@solid-primitives/audio": "1.4.2",
     "@solid-primitives/event-bus": "1.1.2",
-    "@solid-primitives/event-listener": "2.4.5",
     "@solid-primitives/i18n": "2.2.1",
     "@solid-primitives/media": "2.3.3",
-    "@solid-primitives/resize-observer": "2.1.5",
+    "@solid-primitives/resize-observer": "2.1.3",
     "@solid-primitives/scroll": "2.1.3",
     "@solid-primitives/storage": "catalog:",
-    "@solid-primitives/timer": "1.4.4",
     "@solid-primitives/websocket": "1.3.1",
     "@solidjs/meta": "catalog:",
     "@solidjs/router": "catalog:",
-    "@tanstack/solid-query": "5.91.4",
     "@thisbeyond/solid-dnd": "0.7.5",
     "diff": "catalog:",
     "effect": "catalog:",

packages/app/playwright.config.ts

@@ -7,11 +7,6 @@ const serverPort = process.env.PLAYWRIGHT_SERVER_PORT ?? "4096"
 const command = `bun run dev -- --host 0.0.0.0 --port ${port}`
 const reuse = !process.env.CI
 const workers = Number(process.env.PLAYWRIGHT_WORKERS ?? (process.env.CI ? 5 : 0)) || undefined
-const reporter = [["html", { outputFolder: "e2e/playwright-report", open: "never" }], ["line"]] as const
-
-if (process.env.PLAYWRIGHT_JUNIT_OUTPUT) {
-  reporter.push(["junit", { outputFile: process.env.PLAYWRIGHT_JUNIT_OUTPUT }])
-}
 
 export default defineConfig({
   testDir: "./e2e",
@@ -24,7 +19,7 @@ export default defineConfig({
   forbidOnly: !!process.env.CI,
   retries: process.env.CI ? 2 : 0,
   workers,
-  reporter,
+  reporter: [["html", { outputFolder: "e2e/playwright-report", open: "never" }], ["line"]],
   webServer: {
     command,
     url: baseURL,

packages/app/script/e2e-local.ts

@@ -71,7 +71,7 @@ const serverEnv = {
   OPENCODE_E2E_PROJECT_DIR: repoDir,
   OPENCODE_E2E_SESSION_TITLE: "E2E Session",
   OPENCODE_E2E_MESSAGE: "Seeded for UI e2e",
-  OPENCODE_E2E_MODEL: process.env.OPENCODE_E2E_MODEL ?? "opencode/gpt-5-nano",
+  OPENCODE_E2E_MODEL: "opencode/gpt-5-nano",
   OPENCODE_CLIENT: "app",
   OPENCODE_STRICT_CONFIG_DEPS: "true",
 } satisfies Record<string, string>
@@ -87,7 +87,7 @@ const runnerEnv = {
 
 let seed: ReturnType<typeof Bun.spawn> | undefined
 let runner: ReturnType<typeof Bun.spawn> | undefined
-let server: { stop: (close?: boolean) => Promise<void> | void } | undefined
+let server: { stop: () => Promise<void> | void } | undefined
 let inst: { Instance: { disposeAll: () => Promise<void> | void } } | undefined
 let cleaned = false
 
@@ -100,7 +100,7 @@ const cleanup = async () => {
 
   const jobs = [
     inst?.Instance.disposeAll(),
-    typeof server?.stop === "function" ? server.stop() : undefined,
+    server?.stop(),
     keepSandbox ? undefined : fs.rm(sandbox, { recursive: true, force: true }),
   ].filter(Boolean)
   await Promise.allSettled(jobs)
@@ -158,7 +158,7 @@ try {
 
     const servermod = await import("../../opencode/src/server/server")
     inst = await import("../../opencode/src/project/instance")
-    server = await servermod.Server.listen({ port: serverPort, hostname: "127.0.0.1" })
+    server = servermod.Server.listen({ port: serverPort, hostname: "127.0.0.1" })
     console.log(`opencode server listening on http://127.0.0.1:${serverPort}`)
 
     await waitForHealth(`http://127.0.0.1:${serverPort}/global/health`)

packages/app/src/app.tsx

@@ -6,10 +6,9 @@ import { MarkedProvider } from "@opencode-ai/ui/context/marked"
 import { File } from "@opencode-ai/ui/file"
 import { Font } from "@opencode-ai/ui/font"
 import { Splash } from "@opencode-ai/ui/logo"
-import { ThemeProvider } from "@opencode-ai/ui/theme/context"
+import { ThemeProvider } from "@opencode-ai/ui/theme"
 import { MetaProvider } from "@solidjs/meta"
 import { type BaseRouterProps, Navigate, Route, Router } from "@solidjs/router"
-import { QueryClient, QueryClientProvider } from "@tanstack/solid-query"
 import { type Duration, Effect } from "effect"
 import {
   type Component,
@@ -32,11 +31,12 @@ import { FileProvider } from "@/context/file"
 import { GlobalSDKProvider } from "@/context/global-sdk"
 import { GlobalSyncProvider } from "@/context/global-sync"
 import { HighlightsProvider } from "@/context/highlights"
-import { LanguageProvider, type Locale, useLanguage } from "@/context/language"
+import { LanguageProvider, useLanguage } from "@/context/language"
 import { LayoutProvider } from "@/context/layout"
 import { ModelsProvider } from "@/context/models"
 import { NotificationProvider } from "@/context/notification"
 import { PermissionProvider } from "@/context/permission"
+import { usePlatform } from "@/context/platform"
 import { PromptProvider } from "@/context/prompt"
 import { ServerConnection, ServerProvider, serverName, useServer } from "@/context/server"
 import { SettingsProvider } from "@/context/settings"
@@ -47,14 +47,9 @@ import { ErrorPage } from "./pages/error"
 import { useCheckServerHealth } from "./utils/server-health"
 
 const HomeRoute = lazy(() => import("@/pages/home"))
-const loadSession = () => import("@/pages/session")
+const Session = lazy(() => import("@/pages/session"))
-const Session = lazy(loadSession)
 const Loading = () => <div class="size-full" />
 
-if (typeof location === "object" && /\/session(?:\/|$)/.test(location.pathname)) {
-  void loadSession()
-}
-
 const SessionRoute = () => (
   <SessionProviders>
     <Session />
@@ -81,9 +76,9 @@ declare global {
   }
 }
 
-function QueryProvider(props: ParentProps) {
+function MarkedProviderWithNativeParser(props: ParentProps) {
-  const client = new QueryClient()
+  const platform = usePlatform()
-  return <QueryClientProvider client={client}>{props.children}</QueryClientProvider>
+  return <MarkedProvider nativeParser={platform.parseMarkdown}>{props.children}</MarkedProvider>
 }
 
 function AppShellProviders(props: ParentProps) {
@@ -129,7 +124,7 @@ function RouterRoot(props: ParentProps<{ appChildren?: JSX.Element }>) {
   )
 }
 
-export function AppBaseProviders(props: ParentProps<{ locale?: Locale }>) {
+export function AppBaseProviders(props: ParentProps) {
   return (
     <MetaProvider>
       <Font />
@@ -138,16 +133,14 @@ export function AppBaseProviders(props: ParentProps<{ locale?: Locale }>) {
           void window.api?.setTitlebar?.({ mode })
         }}
       >
-        <LanguageProvider locale={props.locale}>
+        <LanguageProvider>
           <UiI18nBridge>
             <ErrorBoundary fallback={(error) => <ErrorPage error={error} />}>
-              <QueryProvider>
+              <DialogProvider>
-                <DialogProvider>
+                <MarkedProviderWithNativeParser>
-                  <MarkedProvider>
+                  <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
-                    <FileComponentProvider component={File}>{props.children}</FileComponentProvider>
+                </MarkedProviderWithNativeParser>
-                  </MarkedProvider>
+              </DialogProvider>
-                </DialogProvider>
-              </QueryProvider>
             </ErrorBoundary>
           </UiI18nBridge>
         </LanguageProvider>
@@ -182,7 +175,8 @@ function ConnectionGate(props: ParentProps<{ disableHealthCheck?: boolean }>) {
             if (checkMode() === "background" || type === "http") return false
           }
         }).pipe(
-          Effect.timeoutOrElse({ duration: "10 seconds", orElse: () => Effect.succeed(false) }),
+          effectMinDuration(checkMode() === "blocking" ? "1.2 seconds" : 0),
+          Effect.timeoutOrElse({ duration: "10 seconds", onTimeout: () => Effect.succeed(false) }),
           Effect.ensuring(Effect.sync(() => setCheckMode("background"))),
           Effect.runPromise,
         ),
@@ -282,11 +276,7 @@ export function AppInterface(props: {
   disableHealthCheck?: boolean
 }) {
   return (
-    <ServerProvider
+    <ServerProvider defaultServer={props.defaultServer} servers={props.servers}>
-      defaultServer={props.defaultServer}
-      disableHealthCheck={props.disableHealthCheck}
-      servers={props.servers}
-    >
       <ConnectionGate disableHealthCheck={props.disableHealthCheck}>
         <ServerKey>
           <GlobalSDKProvider>

packages/app/src/components/debug-bar.tsx

@@ -1,7 +1,6 @@
 import { useIsRouting, useLocation } from "@solidjs/router"
 import { batch, createEffect, onCleanup, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
-import { makeEventListener } from "@solid-primitives/event-listener"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { useLanguage } from "@/context/language"
 
@@ -56,7 +55,7 @@ function Cell(props: { bad?: boolean; dim?: boolean; label: string; tip: string;
     <Tooltip value={props.tip} placement="top">
       <div
         classList={{
-          "flex min-h-[42px] w-full min-w-0 flex-col items-center justify-center rounded-[8px] px-0.5 py-1 text-center": true,
+          "flex min-h-[42px] w-full min-w-0 flex-col items-center justify-center rounded-[8px] bg-white/5 px-0.5 py-1 text-center": true,
           "col-span-2": !!props.wide,
         }}
       >
@@ -350,12 +349,13 @@ export function DebugBar() {
 
     syncHeap()
     start()
-    makeEventListener(document, "visibilitychange", vis)
+    document.addEventListener("visibilitychange", vis)
 
     onCleanup(() => {
       if (one !== 0) cancelAnimationFrame(one)
       if (two !== 0) cancelAnimationFrame(two)
       stop()
+      document.removeEventListener("visibilitychange", vis)
       for (const ob of obs) ob.disconnect()
     })
   })
@@ -363,7 +363,11 @@ export function DebugBar() {
   return (
     <aside
       aria-label={language.t("debugBar.ariaLabel")}
-      class="pointer-events-auto fixed bottom-3 right-3 z-50 w-[308px] max-w-[calc(100vw-1.5rem)] overflow-hidden rounded-xl border border-border-base bg-surface-raised-stronger-non-alpha p-0.5 text-text-strong shadow-[var(--shadow-lg-border-base)] sm:bottom-4 sm:right-4 sm:w-[324px]"
+      class="pointer-events-auto fixed bottom-3 right-3 z-50 w-[308px] max-w-[calc(100vw-1.5rem)] overflow-hidden rounded-xl border p-0.5 text-text-on-interactive-base shadow-[var(--shadow-lg-border-base)] sm:bottom-4 sm:right-4 sm:w-[324px]"
+      style={{
+        "background-color": "color-mix(in srgb, var(--icon-interactive-base) 42%, black)",
+        "border-color": "color-mix(in srgb, white 14%, transparent)",
+      }}
     >
       <div class="grid grid-cols-5 gap-px font-mono">
         <Cell

packages/app/src/components/dialog-connect-provider.tsx

@@ -1,4 +1,4 @@
-import type { ProviderAuthAuthorization, ProviderAuthMethod } from "@opencode-ai/sdk/v2/client"
+import type { ProviderAuthAuthorization } from "@opencode-ai/sdk/v2/client"
 import { Button } from "@opencode-ai/ui/button"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
@@ -9,26 +9,20 @@ import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
 import { Spinner } from "@opencode-ai/ui/spinner"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { showToast } from "@opencode-ai/ui/toast"
-import { createEffect, createMemo, createResource, Match, onCleanup, onMount, Switch } from "solid-js"
+import { createMemo, Match, onCleanup, onMount, Switch } from "solid-js"
 import { createStore, produce } from "solid-js/store"
 import { Link } from "@/components/link"
+import { useLanguage } from "@/context/language"
 import { useGlobalSDK } from "@/context/global-sdk"
 import { useGlobalSync } from "@/context/global-sync"
-import { useLanguage } from "@/context/language"
+import { DialogSelectModel } from "./dialog-select-model"
-import { useProviders } from "@/hooks/use-providers"
+import { DialogSelectProvider } from "./dialog-select-provider"
 
 export function DialogConnectProvider(props: { provider: string }) {
   const dialog = useDialog()
   const globalSync = useGlobalSync()
   const globalSDK = useGlobalSDK()
   const language = useLanguage()
-  const providers = useProviders()
-
-  const all = () => {
-    void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider />)
-    })
-  }
 
   const alive = { value: true }
   const timer = { current: undefined as ReturnType<typeof setTimeout> | undefined }
@@ -40,30 +34,16 @@ export function DialogConnectProvider(props: { provider: string }) {
     timer.current = undefined
   })
 
-  const provider = createMemo(
+  const provider = createMemo(() => globalSync.data.provider.all.find((x) => x.id === props.provider)!)
+  const methods = createMemo(
     () =>
-      providers.all().find((x) => x.id === props.provider) ??
+      globalSync.data.provider_auth[props.provider] ?? [
-      globalSync.data.provider.all.find((x) => x.id === props.provider)!,
+        {
+          type: "api",
+          label: language.t("provider.connect.method.apiKey"),
+        },
+      ],
   )
-  const fallback = createMemo<ProviderAuthMethod[]>(() => [
-    {
-      type: "api" as const,
-      label: language.t("provider.connect.method.apiKey"),
-    },
-  ])
-  const [auth] = createResource(
-    () => props.provider,
-    async () => {
-      const cached = globalSync.data.provider_auth[props.provider]
-      if (cached) return cached
-      const res = await globalSDK.client.provider.auth()
-      if (!alive.value) return fallback()
-      globalSync.set("provider_auth", res.data ?? {})
-      return res.data?.[props.provider] ?? fallback()
-    },
-  )
-  const loading = createMemo(() => auth.loading && !globalSync.data.provider_auth[props.provider])
-  const methods = createMemo(() => auth.latest ?? globalSync.data.provider_auth[props.provider] ?? fallback())
   const [store, setStore] = createStore({
     methodIndex: undefined as undefined | number,
     authorization: undefined as undefined | ProviderAuthAuthorization,
@@ -198,11 +178,7 @@ export function DialogConnectProvider(props: { provider: string }) {
       index: 0,
     })
 
-    const prompts = createMemo<NonNullable<ProviderAuthMethod["prompts"]>>(() => {
+    const prompts = createMemo(() => method()?.prompts ?? [])
-      const value = method()
-      if (value?.type !== "oauth") return []
-      return value.prompts ?? []
-    })
     const matches = (prompt: NonNullable<ReturnType<typeof prompts>[number]>, value: Record<string, string>) => {
       if (!prompt.when) return true
       const actual = value[prompt.when.key]
@@ -321,12 +297,8 @@ export function DialogConnectProvider(props: { provider: string }) {
     listRef?.onKeyDown(e)
   }
 
-  let auto = false
+  onMount(() => {
-  createEffect(() => {
-    if (auto) return
-    if (loading()) return
     if (methods().length === 1) {
-      auto = true
       selectMethod(0)
     }
   })
@@ -344,7 +316,7 @@ export function DialogConnectProvider(props: { provider: string }) {
 
   function goBack() {
     if (methods().length === 1) {
-      all()
+      dialog.show(() => <DialogSelectProvider />)
       return
     }
     if (store.authorization) {
@@ -355,7 +327,7 @@ export function DialogConnectProvider(props: { provider: string }) {
       dispatch({ type: "method.reset" })
       return
     }
-    all()
+    dialog.show(() => <DialogSelectProvider />)
   }
 
   function MethodSelection() {
@@ -602,14 +574,6 @@ export function DialogConnectProvider(props: { provider: string }) {
         <div class="px-2.5 pb-10 flex flex-col gap-6">
           <div onKeyDown={handleKey} tabIndex={0} autofocus={store.methodIndex === undefined ? true : undefined}>
             <Switch>
-              <Match when={loading()}>
-                <div class="text-14-regular text-text-base">
-                  <div class="flex items-center gap-x-2">
-                    <Spinner />
-                    <span>{language.t("provider.connect.status.inProgress")}</span>
-                  </div>
-                </div>
-              </Match>
               <Match when={store.methodIndex === undefined}>
                 <MethodSelection />
               </Match>

packages/app/src/components/dialog-custom-provider-form.ts

@@ -34,6 +34,7 @@ export type FormState = {
   apiKey: string
   models: ModelRow[]
   headers: HeaderRow[]
+  saving: boolean
   err: {
     providerID?: string
     name?: string

packages/app/src/components/dialog-custom-provider.test.ts

@@ -16,6 +16,7 @@ describe("validateCustomProvider", () => {
           { row: "h0", key: " X-Test ", value: " enabled ", err: {} },
           { row: "h1", key: "", value: "", err: {} },
         ],
+        saving: false,
         err: {},
       },
       t,
@@ -59,6 +60,7 @@ describe("validateCustomProvider", () => {
           { row: "h0", key: "Authorization", value: "one", err: {} },
           { row: "h1", key: "authorization", value: "two", err: {} },
         ],
+        saving: false,
         err: {},
       },
       t,

packages/app/src/components/dialog-custom-provider.tsx

@@ -3,7 +3,6 @@ import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { ProviderIcon } from "@opencode-ai/ui/provider-icon"
-import { useMutation } from "@tanstack/solid-query"
 import { TextField } from "@opencode-ai/ui/text-field"
 import { showToast } from "@opencode-ai/ui/toast"
 import { batch, For } from "solid-js"
@@ -32,6 +31,7 @@ export function DialogCustomProvider(props: Props) {
     apiKey: "",
     models: [modelRow()],
     headers: [headerRow()],
+    saving: false,
     err: {},
   })
 
@@ -116,49 +116,48 @@ export function DialogCustomProvider(props: Props) {
     return output.result
   }
 
-  const saveMutation = useMutation(() => ({
+  const save = async (e: SubmitEvent) => {
-    mutationFn: async (result: NonNullable<ReturnType<typeof validate>>) => {
+    e.preventDefault()
-      const disabledProviders = globalSync.data.config.disabled_providers ?? []
+    if (form.saving) return
-      const nextDisabled = disabledProviders.filter((id) => id !== result.providerID)
 
-      if (result.key) {
+    const result = validate()
-        await globalSDK.client.auth.set({
+    if (!result) return
+
+    setForm("saving", true)
+
+    const disabledProviders = globalSync.data.config.disabled_providers ?? []
+    const nextDisabled = disabledProviders.filter((id) => id !== result.providerID)
+
+    const auth = result.key
+      ? globalSDK.client.auth.set({
           providerID: result.providerID,
           auth: {
             type: "api",
             key: result.key,
           },
         })
-      }
+      : Promise.resolve()
 
-      await globalSync.updateConfig({
+    auth
-        provider: { [result.providerID]: result.config },
+      .then(() =>
-        disabled_providers: nextDisabled,
+        globalSync.updateConfig({ provider: { [result.providerID]: result.config }, disabled_providers: nextDisabled }),
+      )
+      .then(() => {
+        dialog.close()
+        showToast({
+          variant: "success",
+          icon: "circle-check",
+          title: language.t("provider.connect.toast.connected.title", { provider: result.name }),
+          description: language.t("provider.connect.toast.connected.description", { provider: result.name }),
+        })
       })
-      return result
+      .catch((err: unknown) => {
-    },
+        const message = err instanceof Error ? err.message : String(err)
-    onSuccess: (result) => {
+        showToast({ title: language.t("common.requestFailed"), description: message })
-      dialog.close()
+      })
-      showToast({
+      .finally(() => {
-        variant: "success",
+        setForm("saving", false)
-        icon: "circle-check",
-        title: language.t("provider.connect.toast.connected.title", { provider: result.name }),
-        description: language.t("provider.connect.toast.connected.description", { provider: result.name }),
       })
-    },
-    onError: (err) => {
-      const message = err instanceof Error ? err.message : String(err)
-      showToast({ title: language.t("common.requestFailed"), description: message })
-    },
-  }))
-
-  const save = (e: SubmitEvent) => {
-    e.preventDefault()
-    if (saveMutation.isPending) return
-
-    const result = validate()
-    if (!result) return
-    saveMutation.mutate(result)
   }
 
   return (
@@ -313,14 +312,8 @@ export function DialogCustomProvider(props: Props) {
             </Button>
           </div>
 
-          <Button
+          <Button class="w-auto self-start" type="submit" size="large" variant="primary" disabled={form.saving}>
-            class="w-auto self-start"
+            {form.saving ? language.t("common.saving") : language.t("common.submit")}
-            type="submit"
-            size="large"
-            variant="primary"
-            disabled={saveMutation.isPending}
-          >
-            {saveMutation.isPending ? language.t("common.saving") : language.t("common.submit")}
           </Button>
         </form>
       </div>

packages/app/src/components/dialog-edit-project.tsx

@@ -2,7 +2,6 @@ import { Button } from "@opencode-ai/ui/button"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { TextField } from "@opencode-ai/ui/text-field"
-import { useMutation } from "@tanstack/solid-query"
 import { Icon } from "@opencode-ai/ui/icon"
 import { createMemo, For, Show } from "solid-js"
 import { createStore } from "solid-js/store"
@@ -29,6 +28,7 @@ export function DialogEditProject(props: { project: LocalProject }) {
     color: props.project.icon?.color || "pink",
     iconUrl: props.project.icon?.override || "",
     startup: props.project.commands?.start ?? "",
+    saving: false,
     dragOver: false,
     iconHover: false,
   })
@@ -71,37 +71,38 @@ export function DialogEditProject(props: { project: LocalProject }) {
     setStore("iconUrl", "")
   }
 
-  const saveMutation = useMutation(() => ({
+  async function handleSubmit(e: SubmitEvent) {
-    mutationFn: async () => {
-      const name = store.name.trim() === folderName() ? "" : store.name.trim()
-      const start = store.startup.trim()
-
-      if (props.project.id && props.project.id !== "global") {
-        await globalSDK.client.project.update({
-          projectID: props.project.id,
-          directory: props.project.worktree,
-          name,
-          icon: { color: store.color, override: store.iconUrl },
-          commands: { start },
-        })
-        globalSync.project.icon(props.project.worktree, store.iconUrl || undefined)
-        dialog.close()
-        return
-      }
-
-      globalSync.project.meta(props.project.worktree, {
-        name,
-        icon: { color: store.color, override: store.iconUrl || undefined },
-        commands: { start: start || undefined },
-      })
-      dialog.close()
-    },
-  }))
-
-  function handleSubmit(e: SubmitEvent) {
     e.preventDefault()
-    if (saveMutation.isPending) return
+
-    saveMutation.mutate()
+    await Promise.resolve()
+      .then(async () => {
+        setStore("saving", true)
+        const name = store.name.trim() === folderName() ? "" : store.name.trim()
+        const start = store.startup.trim()
+
+        if (props.project.id && props.project.id !== "global") {
+          await globalSDK.client.project.update({
+            projectID: props.project.id,
+            directory: props.project.worktree,
+            name,
+            icon: { color: store.color, override: store.iconUrl },
+            commands: { start },
+          })
+          globalSync.project.icon(props.project.worktree, store.iconUrl || undefined)
+          dialog.close()
+          return
+        }
+
+        globalSync.project.meta(props.project.worktree, {
+          name,
+          icon: { color: store.color, override: store.iconUrl || undefined },
+          commands: { start: start || undefined },
+        })
+        dialog.close()
+      })
+      .finally(() => {
+        setStore("saving", false)
+      })
   }
 
   return (
@@ -245,8 +246,8 @@ export function DialogEditProject(props: { project: LocalProject }) {
           <Button type="button" variant="ghost" size="large" onClick={() => dialog.close()}>
             {language.t("common.cancel")}
           </Button>
-          <Button type="submit" variant="primary" size="large" disabled={saveMutation.isPending}>
+          <Button type="submit" variant="primary" size="large" disabled={store.saving}>
-            {saveMutation.isPending ? language.t("common.saving") : language.t("common.save")}
+            {store.saving ? language.t("common.saving") : language.t("common.save")}
           </Button>
         </div>
       </form>

packages/app/src/components/dialog-select-mcp.tsx

@@ -1,12 +1,9 @@
-import { useMutation } from "@tanstack/solid-query"
+import { Component, createMemo, createSignal, Show } from "solid-js"
-import { Component, createEffect, createMemo, on, Show } from "solid-js"
-import { createStore } from "solid-js/store"
 import { useSync } from "@/context/sync"
 import { useSDK } from "@/context/sdk"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { List } from "@opencode-ai/ui/list"
 import { Switch } from "@opencode-ai/ui/switch"
-import { showToast } from "@opencode-ai/ui/toast"
 import { useLanguage } from "@/context/language"
 
 const statusLabels = {
@@ -20,48 +17,7 @@ export const DialogSelectMcp: Component = () => {
   const sync = useSync()
   const sdk = useSDK()
   const language = useLanguage()
-  const [state, setState] = createStore({
+  const [loading, setLoading] = createSignal<string | null>(null)
-    done: false,
-    loading: false,
-  })
-
-  createEffect(
-    on(
-      () => sync.data.mcp_ready,
-      (ready, prev) => {
-        if (!ready && prev) setState("done", false)
-      },
-      { defer: true },
-    ),
-  )
-
-  createEffect(() => {
-    if (state.done || state.loading) return
-    if (sync.data.mcp_ready) {
-      setState("done", true)
-      return
-    }
-
-    setState("loading", true)
-    void sdk.client.mcp
-      .status()
-      .then((result) => {
-        sync.set("mcp", result.data ?? {})
-        sync.set("mcp_ready", true)
-        setState("done", true)
-      })
-      .catch((err) => {
-        setState("done", true)
-        showToast({
-          variant: "error",
-          title: language.t("common.requestFailed"),
-          description: err instanceof Error ? err.message : String(err),
-        })
-      })
-      .finally(() => {
-        setState("loading", false)
-      })
-  })
 
   const items = createMemo(() =>
     Object.entries(sync.data.mcp ?? {})
@@ -69,8 +25,10 @@ export const DialogSelectMcp: Component = () => {
       .sort((a, b) => a.name.localeCompare(b.name)),
   )
 
-  const toggle = useMutation(() => ({
+  const toggle = async (name: string) => {
-    mutationFn: async (name: string) => {
+    if (loading()) return
+    setLoading(name)
+    try {
       const status = sync.data.mcp[name]
       if (status?.status === "connected") {
         await sdk.client.mcp.disconnect({ name })
@@ -80,8 +38,10 @@ export const DialogSelectMcp: Component = () => {
 
       const result = await sdk.client.mcp.status()
       if (result.data) sync.set("mcp", result.data)
-    },
+    } finally {
-  }))
+      setLoading(null)
+    }
+  }
 
   const enabledCount = createMemo(() => items().filter((i) => i.status === "connected").length)
   const totalCount = createMemo(() => items().length)
@@ -99,8 +59,7 @@ export const DialogSelectMcp: Component = () => {
         filterKeys={["name", "status"]}
         sortBy={(a, b) => a.name.localeCompare(b.name)}
         onSelect={(x) => {
-          if (!x || toggle.isPending) return
+          if (x) toggle(x.name)
-          toggle.mutate(x.name)
         }}
       >
         {(i) => {
@@ -124,7 +83,7 @@ export const DialogSelectMcp: Component = () => {
                   <Show when={statusLabel()}>
                     <span class="text-11-regular text-text-weaker">{statusLabel()}</span>
                   </Show>
-                  <Show when={toggle.isPending && toggle.variables === i.name}>
+                  <Show when={loading() === i.name}>
                     <span class="text-11-regular text-text-weak">{language.t("common.loading.ellipsis")}</span>
                   </Show>
                 </div>
@@ -133,14 +92,7 @@ export const DialogSelectMcp: Component = () => {
                 </Show>
               </div>
               <div onClick={(e) => e.stopPropagation()}>
-                <Switch
+                <Switch checked={enabled()} disabled={loading() === i.name} onChange={() => toggle(i.name)} />
-                  checked={enabled()}
-                  disabled={toggle.isPending && toggle.variables === i.name}
-                  onChange={() => {
-                    if (toggle.isPending) return
-                    toggle.mutate(i.name)
-                  }}
-                />
               </div>
             </div>
           )

packages/app/src/components/dialog-select-model-unpaid.tsx

@@ -8,6 +8,8 @@ import { Tooltip } from "@opencode-ai/ui/tooltip"
 import { type Component, Show } from "solid-js"
 import { useLocal } from "@/context/local"
 import { popularProviders, useProviders } from "@/hooks/use-providers"
+import { DialogConnectProvider } from "./dialog-connect-provider"
+import { DialogSelectProvider } from "./dialog-select-provider"
 import { ModelTooltip } from "./model-tooltip"
 import { useLanguage } from "@/context/language"
 
@@ -19,18 +21,6 @@ export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props
   const providers = useProviders()
   const language = useLanguage()
 
-  const connect = (provider: string) => {
-    void import("./dialog-connect-provider").then((x) => {
-      dialog.show(() => <x.DialogConnectProvider provider={provider} />)
-    })
-  }
-
-  const all = () => {
-    void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider />)
-    })
-  }
-
   let listRef: ListRef | undefined
   const handleKeyDown = (e: KeyboardEvent) => {
     if (e.key === "Escape") return
@@ -101,7 +91,7 @@ export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props
                 }}
                 onSelect={(x) => {
                   if (!x) return
-                  connect(x.id)
+                  dialog.show(() => <DialogConnectProvider provider={x.id} />)
                 }}
               >
                 {(i) => (
@@ -132,7 +122,9 @@ export const DialogSelectModelUnpaid: Component<{ model?: ModelState }> = (props
                 variant="ghost"
                 class="w-full justify-start px-[11px] py-3.5 gap-4.5 text-14-medium"
                 icon="dot-grid"
-                onClick={all}
+                onClick={() => {
+                  dialog.show(() => <DialogSelectProvider />)
+                }}
               >
                 {language.t("dialog.provider.viewAll")}
               </Button>

packages/app/src/components/dialog-select-model.tsx

@@ -10,6 +10,8 @@ import { Tag } from "@opencode-ai/ui/tag"
 import { Dialog } from "@opencode-ai/ui/dialog"
 import { List } from "@opencode-ai/ui/list"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
+import { DialogSelectProvider } from "./dialog-select-provider"
+import { DialogManageModels } from "./dialog-manage-models"
 import { ModelTooltip } from "./model-tooltip"
 import { useLanguage } from "@/context/language"
 
@@ -86,7 +88,6 @@ const ModelList: Component<{
 }
 
 type ModelSelectorTriggerProps = Omit<ComponentProps<typeof Kobalte.Trigger>, "as" | "ref">
-type Dismiss = "escape" | "outside" | "select" | "manage" | "provider"
 
 export function ModelSelectorPopover(props: {
   provider?: string
@@ -94,34 +95,24 @@ export function ModelSelectorPopover(props: {
   children?: JSX.Element
   triggerAs?: ValidComponent
   triggerProps?: ModelSelectorTriggerProps
-  onClose?: (cause: "escape" | "select") => void
 }) {
   const [store, setStore] = createStore<{
     open: boolean
-    dismiss: Dismiss | null
+    dismiss: "escape" | "outside" | null
   }>({
     open: false,
     dismiss: null,
   })
   const dialog = useDialog()
 
-  const close = (dismiss: Dismiss) => {
-    setStore("dismiss", dismiss)
-    setStore("open", false)
-  }
-
   const handleManage = () => {
-    close("manage")
+    setStore("open", false)
-    void import("./dialog-manage-models").then((x) => {
+    dialog.show(() => <DialogManageModels />)
-      dialog.show(() => <x.DialogManageModels />)
-    })
   }
 
   const handleConnectProvider = () => {
-    close("provider")
+    setStore("open", false)
-    void import("./dialog-select-provider").then((x) => {
+    dialog.show(() => <DialogSelectProvider />)
-      dialog.show(() => <x.DialogSelectProvider />)
-    })
   }
   const language = useLanguage()
 
@@ -143,19 +134,21 @@ export function ModelSelectorPopover(props: {
         <Kobalte.Content
           class="w-72 h-80 flex flex-col p-2 rounded-md border border-border-base bg-surface-raised-stronger-non-alpha shadow-md z-50 outline-none overflow-hidden"
           onEscapeKeyDown={(event) => {
-            close("escape")
+            setStore("dismiss", "escape")
+            setStore("open", false)
             event.preventDefault()
             event.stopPropagation()
           }}
-          onPointerDownOutside={() => close("outside")}
+          onPointerDownOutside={() => {
-          onFocusOutside={() => close("outside")}
+            setStore("dismiss", "outside")
+            setStore("open", false)
+          }}
+          onFocusOutside={() => {
+            setStore("dismiss", "outside")
+            setStore("open", false)
+          }}
           onCloseAutoFocus={(event) => {
-            const dismiss = store.dismiss
+            if (store.dismiss === "outside") event.preventDefault()
-            if (dismiss === "outside") event.preventDefault()
-            if (dismiss === "escape" || dismiss === "select") {
-              event.preventDefault()
-              props.onClose?.(dismiss)
-            }
             setStore("dismiss", null)
           }}
         >
@@ -163,7 +156,7 @@ export function ModelSelectorPopover(props: {
           <ModelList
             provider={props.provider}
             model={props.model}
-            onSelect={() => close("select")}
+            onSelect={() => setStore("open", false)}
             class="p-1"
             action={
               <div class="flex items-center gap-1">
@@ -200,29 +193,26 @@ export const DialogSelectModel: Component<{ provider?: string; model?: ModelStat
   const dialog = useDialog()
   const language = useLanguage()
 
-  const provider = () => {
-    void import("./dialog-select-provider").then((x) => {
-      dialog.show(() => <x.DialogSelectProvider />)
-    })
-  }
-
-  const manage = () => {
-    void import("./dialog-manage-models").then((x) => {
-      dialog.show(() => <x.DialogManageModels />)
-    })
-  }
-
   return (
     <Dialog
       title={language.t("dialog.model.select.title")}
       action={
-        <Button class="h-7 -my-1 text-14-medium" icon="plus-small" tabIndex={-1} onClick={provider}>
+        <Button
+          class="h-7 -my-1 text-14-medium"
+          icon="plus-small"
+          tabIndex={-1}
+          onClick={() => dialog.show(() => <DialogSelectProvider />)}
+        >
           {language.t("command.provider.connect")}
         </Button>
       }
     >
       <ModelList provider={props.provider} model={props.model} onSelect={() => dialog.close()} />
-      <Button variant="ghost" class="ml-3 mt-5 mb-6 text-text-base self-start" onClick={manage}>
+      <Button
+        variant="ghost"
+        class="ml-3 mt-5 mb-6 text-text-base self-start"
+        onClick={() => dialog.show(() => <DialogManageModels />)}
+      >
         {language.t("dialog.model.manage")}
       </Button>
     </Dialog>

packages/app/src/components/dialog-select-server.tsx

@@ -6,7 +6,6 @@ import { Icon } from "@opencode-ai/ui/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
 import { List } from "@opencode-ai/ui/list"
 import { TextField } from "@opencode-ai/ui/text-field"
-import { useMutation } from "@tanstack/solid-query"
 import { showToast } from "@opencode-ai/ui/toast"
 import { useNavigate } from "@solidjs/router"
 import { createEffect, createMemo, createResource, onCleanup, Show } from "solid-js"
@@ -187,6 +186,7 @@ export function DialogSelectServer() {
       name: "",
       username: DEFAULT_USERNAME,
       password: "",
+      adding: false,
       error: "",
       showForm: false,
       status: undefined as boolean | undefined,
@@ -198,6 +198,7 @@ export function DialogSelectServer() {
       username: "",
       password: "",
       error: "",
+      busy: false,
       status: undefined as boolean | undefined,
     },
   })
@@ -208,6 +209,7 @@ export function DialogSelectServer() {
       name: "",
       username: DEFAULT_USERNAME,
       password: "",
+      adding: false,
       error: "",
       showForm: false,
       status: undefined,
@@ -222,78 +224,10 @@ export function DialogSelectServer() {
       password: "",
       error: "",
       status: undefined,
+      busy: false,
     })
   }
 
-  const addMutation = useMutation(() => ({
-    mutationFn: async (value: string) => {
-      const normalized = normalizeServerUrl(value)
-      if (!normalized) {
-        resetAdd()
-        return
-      }
-
-      const conn: ServerConnection.Http = {
-        type: "http",
-        http: { url: normalized },
-      }
-      if (store.addServer.name.trim()) conn.displayName = store.addServer.name.trim()
-      if (store.addServer.password) conn.http.password = store.addServer.password
-      if (store.addServer.password && store.addServer.username) conn.http.username = store.addServer.username
-      const result = await checkServerHealth(conn.http)
-      if (!result.healthy) {
-        setStore("addServer", { error: language.t("dialog.server.add.error") })
-        return
-      }
-
-      resetAdd()
-      await select(conn, true)
-    },
-  }))
-
-  const editMutation = useMutation(() => ({
-    mutationFn: async (input: { original: ServerConnection.Any; value: string }) => {
-      if (input.original.type !== "http") return
-      const normalized = normalizeServerUrl(input.value)
-      if (!normalized) {
-        resetEdit()
-        return
-      }
-
-      const name = store.editServer.name.trim() || undefined
-      const username = store.editServer.username || undefined
-      const password = store.editServer.password || undefined
-      const existingName = input.original.displayName
-      if (
-        normalized === input.original.http.url &&
-        name === existingName &&
-        username === input.original.http.username &&
-        password === input.original.http.password
-      ) {
-        resetEdit()
-        return
-      }
-
-      const conn: ServerConnection.Http = {
-        type: "http",
-        displayName: name,
-        http: { url: normalized, username, password },
-      }
-      const result = await checkServerHealth(conn.http)
-      if (!result.healthy) {
-        setStore("editServer", { error: language.t("dialog.server.add.error") })
-        return
-      }
-      if (normalized === input.original.http.url) {
-        server.add(conn)
-      } else {
-        replaceServer(input.original, conn)
-      }
-
-      resetEdit()
-    },
-  }))
-
   const replaceServer = (original: ServerConnection.Http, next: ServerConnection.Http) => {
     const active = server.key
     const newConn = server.add(next)
@@ -362,7 +296,7 @@ export function DialogSelectServer() {
   }
 
   const handleAddChange = (value: string) => {
-    if (addMutation.isPending) return
+    if (store.addServer.adding) return
     setStore("addServer", { url: value, error: "" })
     void previewStatus(value, store.addServer.username, store.addServer.password, (next) =>
       setStore("addServer", { status: next }),
@@ -370,12 +304,12 @@ export function DialogSelectServer() {
   }
 
   const handleAddNameChange = (value: string) => {
-    if (addMutation.isPending) return
+    if (store.addServer.adding) return
     setStore("addServer", { name: value, error: "" })
   }
 
   const handleAddUsernameChange = (value: string) => {
-    if (addMutation.isPending) return
+    if (store.addServer.adding) return
     setStore("addServer", { username: value, error: "" })
     void previewStatus(store.addServer.url, value, store.addServer.password, (next) =>
       setStore("addServer", { status: next }),
@@ -383,7 +317,7 @@ export function DialogSelectServer() {
   }
 
   const handleAddPasswordChange = (value: string) => {
-    if (addMutation.isPending) return
+    if (store.addServer.adding) return
     setStore("addServer", { password: value, error: "" })
     void previewStatus(store.addServer.url, store.addServer.username, value, (next) =>
       setStore("addServer", { status: next }),
@@ -391,7 +325,7 @@ export function DialogSelectServer() {
   }
 
   const handleEditChange = (value: string) => {
-    if (editMutation.isPending) return
+    if (store.editServer.busy) return
     setStore("editServer", { value, error: "" })
     void previewStatus(value, store.editServer.username, store.editServer.password, (next) =>
       setStore("editServer", { status: next }),
@@ -399,12 +333,12 @@ export function DialogSelectServer() {
   }
 
   const handleEditNameChange = (value: string) => {
-    if (editMutation.isPending) return
+    if (store.editServer.busy) return
     setStore("editServer", { name: value, error: "" })
   }
 
   const handleEditUsernameChange = (value: string) => {
-    if (editMutation.isPending) return
+    if (store.editServer.busy) return
     setStore("editServer", { username: value, error: "" })
     void previewStatus(store.editServer.value, value, store.editServer.password, (next) =>
       setStore("editServer", { status: next }),
@@ -412,13 +346,85 @@ export function DialogSelectServer() {
   }
 
   const handleEditPasswordChange = (value: string) => {
-    if (editMutation.isPending) return
+    if (store.editServer.busy) return
     setStore("editServer", { password: value, error: "" })
     void previewStatus(store.editServer.value, store.editServer.username, value, (next) =>
       setStore("editServer", { status: next }),
     )
   }
 
+  async function handleAdd(value: string) {
+    if (store.addServer.adding) return
+    const normalized = normalizeServerUrl(value)
+    if (!normalized) {
+      resetAdd()
+      return
+    }
+
+    setStore("addServer", { adding: true, error: "" })
+
+    const conn: ServerConnection.Http = {
+      type: "http",
+      http: { url: normalized },
+    }
+    if (store.addServer.name.trim()) conn.displayName = store.addServer.name.trim()
+    if (store.addServer.password) conn.http.password = store.addServer.password
+    if (store.addServer.password && store.addServer.username) conn.http.username = store.addServer.username
+    const result = await checkServerHealth(conn.http)
+    setStore("addServer", { adding: false })
+    if (!result.healthy) {
+      setStore("addServer", { error: language.t("dialog.server.add.error") })
+      return
+    }
+
+    resetAdd()
+    await select(conn, true)
+  }
+
+  async function handleEdit(original: ServerConnection.Any, value: string) {
+    if (store.editServer.busy || original.type !== "http") return
+    const normalized = normalizeServerUrl(value)
+    if (!normalized) {
+      resetEdit()
+      return
+    }
+
+    const name = store.editServer.name.trim() || undefined
+    const username = store.editServer.username || undefined
+    const password = store.editServer.password || undefined
+    const existingName = original.displayName
+    if (
+      normalized === original.http.url &&
+      name === existingName &&
+      username === original.http.username &&
+      password === original.http.password
+    ) {
+      resetEdit()
+      return
+    }
+
+    setStore("editServer", { busy: true, error: "" })
+
+    const conn: ServerConnection.Http = {
+      type: "http",
+      displayName: name,
+      http: { url: normalized, username, password },
+    }
+    const result = await checkServerHealth(conn.http)
+    setStore("editServer", { busy: false })
+    if (!result.healthy) {
+      setStore("editServer", { error: language.t("dialog.server.add.error") })
+      return
+    }
+    if (normalized === original.http.url) {
+      server.add(conn)
+    } else {
+      replaceServer(original, conn)
+    }
+
+    resetEdit()
+  }
+
   const mode = createMemo<"list" | "add" | "edit">(() => {
     if (store.editServer.id) return "edit"
     if (store.addServer.showForm) return "add"
@@ -458,26 +464,23 @@ export function DialogSelectServer() {
       password: conn.http.password ?? "",
       error: "",
       status: store.status[ServerConnection.key(conn)]?.healthy,
+      busy: false,
     })
   }
 
   const submitForm = () => {
     if (mode() === "add") {
-      if (addMutation.isPending) return
+      void handleAdd(store.addServer.url)
-      setStore("addServer", { error: "" })
-      addMutation.mutate(store.addServer.url)
       return
     }
     const original = editing()
     if (!original) return
-    if (editMutation.isPending) return
+    void handleEdit(original, store.editServer.value)
-    setStore("editServer", { error: "" })
-    editMutation.mutate({ original, value: store.editServer.value })
   }
 
   const isFormMode = createMemo(() => mode() !== "list")
   const isAddMode = createMemo(() => mode() === "add")
-  const formBusy = createMemo(() => (isAddMode() ? addMutation.isPending : editMutation.isPending))
+  const formBusy = createMemo(() => (isAddMode() ? store.addServer.adding : store.editServer.busy))
 
   const formTitle = createMemo(() => {
     if (!isFormMode()) return language.t("dialog.server.title")

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

@@ -27,6 +27,7 @@ import { IconButton } from "@opencode-ai/ui/icon-button"
 import { Select } from "@opencode-ai/ui/select"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { ModelSelectorPopover } from "@/components/dialog-select-model"
+import { DialogSelectModelUnpaid } from "@/components/dialog-select-model-unpaid"
 import { useProviders } from "@/hooks/use-providers"
 import { useCommand } from "@/context/command"
 import { Persist, persisted } from "@/utils/persist"
@@ -243,6 +244,23 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
       },
   )
   const working = createMemo(() => status()?.type !== "idle")
+  const tip = () => {
+    if (working()) {
+      return (
+        <div class="flex items-center gap-2">
+          <span>{language.t("prompt.action.stop")}</span>
+          <span class="text-icon-base text-12-medium text-[10px]!">{language.t("common.key.esc")}</span>
+        </div>
+      )
+    }
+
+    return (
+      <div class="flex items-center gap-2">
+        <span>{language.t("prompt.action.send")}</span>
+        <Icon name="enter" size="small" class="text-icon-base" />
+      </div>
+    )
+  }
   const imageAttachments = createMemo(() =>
     prompt.current().filter((part): part is ImageAttachmentPart => part.type === "image"),
   )
@@ -280,31 +298,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     if (store.mode === "shell") return 0
     return prompt.context.items().filter((item) => !!item.comment?.trim()).length
   })
-  const blank = createMemo(() => {
-    const text = prompt
-      .current()
-      .map((part) => ("content" in part ? part.content : ""))
-      .join("")
-    return text.trim().length === 0 && imageAttachments().length === 0 && commentCount() === 0
-  })
-  const stopping = createMemo(() => working() && blank())
-  const tip = () => {
-    if (stopping()) {
-      return (
-        <div class="flex items-center gap-2">
-          <span>{language.t("prompt.action.stop")}</span>
-          <span class="text-icon-base text-12-medium text-[10px]!">{language.t("common.key.esc")}</span>
-        </div>
-      )
-    }
-
-    return (
-      <div class="flex items-center gap-2">
-        <span>{language.t("prompt.action.send")}</span>
-        <Icon name="enter" size="small" class="text-icon-base" />
-      </div>
-    )
-  }
 
   const contextItems = createMemo(() => {
     const items = prompt.context.items()
@@ -510,15 +503,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     return getCursorPosition(editorRef)
   }
 
-  const restoreFocus = () => {
-    requestAnimationFrame(() => {
-      const cursor = prompt.cursor() ?? promptLength(prompt.current())
-      editorRef.focus()
-      setCursorPosition(editorRef, cursor)
-      queueScroll()
-    })
-  }
-
   const renderEditorWithCursor = (parts: Prompt) => {
     const cursor = currentCursor()
     renderEditor(parts)
@@ -588,7 +572,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
       const open = recent()
       const seen = new Set(open)
       const pinned: AtOption[] = open.map((path) => ({ type: "file", path, display: path, recent: true }))
-      if (!query.trim()) return [...agents, ...pinned]
       const paths = await files.searchFilesAndDirectories(query)
       const fileOptions: AtOption[] = paths
         .filter((path) => !seen.has(path))
@@ -641,18 +624,17 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     if (!cmd) return
     promptProbe.select(cmd.id)
     closePopover()
-    const images = imageAttachments()
 
     if (cmd.type === "custom") {
       const text = `/${cmd.trigger} `
       setEditorText(text)
-      prompt.set([{ type: "text", content: text, start: 0, end: text.length }, ...images], text.length)
+      prompt.set([{ type: "text", content: text, start: 0, end: text.length }], text.length)
       focusEditorEnd()
       return
     }
 
     clearEditor()
-    prompt.set([...DEFAULT_PROMPT, ...images], 0)
+    prompt.set([{ type: "text", content: "", start: 0, end: 0 }], 0)
     command.trigger(cmd.id, "slash")
   }
 
@@ -1061,7 +1043,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     return true
   }
 
-  const { addAttachments, removeAttachment, handlePaste } = createPromptAttachments({
+  const { addAttachment, removeAttachment, handlePaste } = createPromptAttachments({
     editor: () => editorRef,
     isDialogActive: () => !!dialog.active,
     setDraggingType: (type) => setStore("draggingType", type),
@@ -1079,6 +1061,17 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
     if (!id) return permission.isAutoAcceptingDirectory(sdk.directory)
     return permission.isAutoAccepting(id, sdk.directory)
   })
+  const acceptLabel = createMemo(() =>
+    language.t(accepting() ? "command.permissions.autoaccept.disable" : "command.permissions.autoaccept.enable"),
+  )
+  const toggleAccept = () => {
+    if (!params.id) {
+      permission.toggleAutoAcceptDirectory(sdk.directory)
+      return
+    }
+
+    permission.toggleAutoAccept(params.id, sdk.directory)
+  }
 
   const { abort, handleSubmit } = createPromptSubmit({
     info,
@@ -1322,7 +1315,11 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
           onMouseDown={(e) => {
             const target = e.target
             if (!(target instanceof HTMLElement)) return
-            if (target.closest('[data-action="prompt-attach"], [data-action="prompt-submit"]')) {
+            if (
+              target.closest(
+                '[data-action="prompt-attach"], [data-action="prompt-submit"], [data-action="prompt-permissions"]',
+              )
+            ) {
               return
             }
             editorRef?.focus()
@@ -1346,9 +1343,6 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
               autocapitalize={store.mode === "normal" ? "sentences" : "off"}
               autocorrect={store.mode === "normal" ? "on" : "off"}
               spellcheck={store.mode === "normal"}
-              inputMode="text"
-              // @ts-expect-error
-              autocomplete="off"
               onInput={handleInput}
               onPaste={handlePaste}
               onCompositionStart={handleCompositionStart}
@@ -1394,23 +1388,27 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
               class="hidden"
               onChange={(e) => {
                 const list = e.currentTarget.files
-                if (list) void addAttachments(Array.from(list))
+                if (list) {
+                  for (const file of Array.from(list)) {
+                    void addAttachment(file)
+                  }
+                }
                 e.currentTarget.value = ""
               }}
             />
 
             <div class="flex items-center gap-1 pointer-events-auto">
-              <Tooltip placement="top" inactive={!working() && blank()} value={tip()}>
+              <Tooltip placement="top" inactive={!prompt.dirty() && !working()} value={tip()}>
                 <IconButton
                   data-action="prompt-submit"
                   type="submit"
-                  disabled={store.mode !== "normal" || (!working() && blank())}
+                  disabled={store.mode !== "normal" || (!prompt.dirty() && !working() && commentCount() === 0)}
                   tabIndex={store.mode === "normal" ? undefined : -1}
-                  icon={stopping() ? "stop" : "arrow-up"}
+                  icon={working() ? "stop" : "arrow-up"}
                   variant="primary"
                   class="size-8"
                   style={buttons()}
-                  aria-label={stopping() ? language.t("prompt.action.stop") : language.t("prompt.action.send")}
+                  aria-label={working() ? language.t("prompt.action.stop") : language.t("prompt.action.send")}
                 />
               </Tooltip>
             </div>
@@ -1473,10 +1471,7 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                       size="normal"
                       options={agentNames()}
                       current={local.agent.current()?.name ?? ""}
-                      onSelect={(value) => {
+                      onSelect={local.agent.set}
-                        local.agent.set(value)
-                        restoreFocus()
-                      }}
                       class="capitalize max-w-[160px] text-text-base"
                       valueClass="truncate text-13-regular text-text-base"
                       triggerStyle={control()}
@@ -1485,66 +1480,28 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                     />
                   </TooltipKeybind>
                 </div>
-                <Show when={store.mode !== "shell"}>
+                <div data-component="prompt-model-control">
-                  <div data-component="prompt-model-control">
+                  <Show
-                    <Show
+                    when={providers.paid().length > 0}
-                      when={providers.paid().length > 0}
+                    fallback={
-                      fallback={
-                        <TooltipKeybind
-                          placement="top"
-                          gutter={4}
-                          title={language.t("command.model.choose")}
-                          keybind={command.keybind("model.choose")}
-                        >
-                          <Button
-                            data-action="prompt-model"
-                            as="div"
-                            variant="ghost"
-                            size="normal"
-                            class="min-w-0 max-w-[320px] text-13-regular text-text-base group"
-                            style={control()}
-                            onClick={() => {
-                              void import("@/components/dialog-select-model-unpaid").then((x) => {
-                                dialog.show(() => <x.DialogSelectModelUnpaid model={local.model} />)
-                              })
-                            }}
-                          >
-                            <Show when={local.model.current()?.provider?.id}>
-                              <ProviderIcon
-                                id={local.model.current()?.provider?.id ?? ""}
-                                class="size-4 shrink-0 opacity-40 group-hover:opacity-100 transition-opacity duration-150"
-                                style={{ "will-change": "opacity", transform: "translateZ(0)" }}
-                              />
-                            </Show>
-                            <span class="truncate">
-                              {local.model.current()?.name ?? language.t("dialog.model.select.title")}
-                            </span>
-                            <Icon name="chevron-down" size="small" class="shrink-0" />
-                          </Button>
-                        </TooltipKeybind>
-                      }
-                    >
                       <TooltipKeybind
                         placement="top"
                         gutter={4}
                         title={language.t("command.model.choose")}
                         keybind={command.keybind("model.choose")}
                       >
-                        <ModelSelectorPopover
+                        <Button
-                          model={local.model}
+                          data-action="prompt-model"
-                          triggerAs={Button}
+                          as="div"
-                          triggerProps={{
+                          variant="ghost"
-                            variant: "ghost",
+                          size="normal"
-                            size: "normal",
+                          class="min-w-0 max-w-[320px] text-13-regular text-text-base group"
-                            style: control(),
+                          style={control()}
-                            class: "min-w-0 max-w-[320px] text-13-regular text-text-base group",
+                          onClick={() => dialog.show(() => <DialogSelectModelUnpaid model={local.model} />)}
-                            "data-action": "prompt-model",
-                          }}
-                          onClose={restoreFocus}
                         >
                           <Show when={local.model.current()?.provider?.id}>
                             <ProviderIcon
-                              id={local.model.current()?.provider?.id ?? ""}
+                              id={local.model.current()!.provider.id}
                               class="size-4 shrink-0 opacity-40 group-hover:opacity-100 transition-opacity duration-150"
                               style={{ "will-change": "opacity", transform: "translateZ(0)" }}
                             />
@@ -1553,35 +1510,85 @@ export const PromptInput: Component<PromptInputProps> = (props) => {
                             {local.model.current()?.name ?? language.t("dialog.model.select.title")}
                           </span>
                           <Icon name="chevron-down" size="small" class="shrink-0" />
-                        </ModelSelectorPopover>
+                        </Button>
                       </TooltipKeybind>
-                    </Show>
+                    }
-                  </div>
+                  >
-                  <div data-component="prompt-variant-control">
                     <TooltipKeybind
                       placement="top"
                       gutter={4}
-                      title={language.t("command.model.variant.cycle")}
+                      title={language.t("command.model.choose")}
-                      keybind={command.keybind("model.variant.cycle")}
+                      keybind={command.keybind("model.choose")}
                     >
-                      <Select
+                      <ModelSelectorPopover
-                        size="normal"
+                        model={local.model}
-                        options={variants()}
+                        triggerAs={Button}
-                        current={local.model.variant.current() ?? "default"}
+                        triggerProps={{
-                        label={(x) => (x === "default" ? language.t("common.default") : x)}
+                          variant: "ghost",
-                        onSelect={(value) => {
+                          size: "normal",
-                          local.model.variant.set(value === "default" ? undefined : value)
+                          style: control(),
-                          restoreFocus()
+                          class: "min-w-0 max-w-[320px] text-13-regular text-text-base group",
+                          "data-action": "prompt-model",
                         }}
-                        class="capitalize max-w-[160px] text-text-base"
+                      >
-                        valueClass="truncate text-13-regular text-text-base"
+                        <Show when={local.model.current()?.provider?.id}>
-                        triggerStyle={control()}
+                          <ProviderIcon
-                        triggerProps={{ "data-action": "prompt-model-variant" }}
+                            id={local.model.current()!.provider.id}
-                        variant="ghost"
+                            class="size-4 shrink-0 opacity-40 group-hover:opacity-100 transition-opacity duration-150"
-                      />
+                            style={{ "will-change": "opacity", transform: "translateZ(0)" }}
+                          />
+                        </Show>
+                        <span class="truncate">
+                          {local.model.current()?.name ?? language.t("dialog.model.select.title")}
+                        </span>
+                        <Icon name="chevron-down" size="small" class="shrink-0" />
+                      </ModelSelectorPopover>
                     </TooltipKeybind>
-                  </div>
+                  </Show>
-                </Show>
+                </div>
+                <div data-component="prompt-variant-control">
+                  <TooltipKeybind
+                    placement="top"
+                    gutter={4}
+                    title={language.t("command.model.variant.cycle")}
+                    keybind={command.keybind("model.variant.cycle")}
+                  >
+                    <Select
+                      size="normal"
+                      options={variants()}
+                      current={local.model.variant.current() ?? "default"}
+                      label={(x) => (x === "default" ? language.t("common.default") : x)}
+                      onSelect={(x) => local.model.variant.set(x === "default" ? undefined : x)}
+                      class="capitalize max-w-[160px] text-text-base"
+                      valueClass="truncate text-13-regular text-text-base"
+                      triggerStyle={control()}
+                      triggerProps={{ "data-action": "prompt-model-variant" }}
+                      variant="ghost"
+                    />
+                  </TooltipKeybind>
+                </div>
+                <TooltipKeybind
+                  placement="top"
+                  gutter={8}
+                  title={acceptLabel()}
+                  keybind={command.keybind("permissions.autoaccept")}
+                >
+                  <Button
+                    data-action="prompt-permissions"
+                    variant="ghost"
+                    onClick={toggleAccept}
+                    classList={{
+                      "h-7 w-7 p-0 shrink-0 flex items-center justify-center": true,
+                      "text-text-base": !accepting(),
+                      "hover:bg-surface-success-base": accepting(),
+                    }}
+                    style={control()}
+                    aria-label={acceptLabel()}
+                    aria-pressed={accepting()}
+                  >
+                    <Icon name="shield" size="small" classList={{ "text-icon-success-base": accepting() }} />
+                  </Button>
+                </TooltipKeybind>
               </div>
             </div>
           </div>

packages/app/src/components/prompt-input/attachments.ts

@@ -1,5 +1,4 @@
-import { onMount } from "solid-js"
+import { onCleanup, onMount } from "solid-js"
-import { makeEventListener } from "@solid-primitives/event-listener"
 import { showToast } from "@opencode-ai/ui/toast"
 import { usePrompt, type ContentPart, type ImageAttachmentPart } from "@/context/prompt"
 import { useLanguage } from "@/context/language"
@@ -72,18 +71,6 @@ export function createPromptAttachments(input: PromptAttachmentsInput) {
 
   const addAttachment = (file: File) => add(file)
 
-  const addAttachments = async (files: File[], toast = true) => {
-    let found = false
-
-    for (const file of files) {
-      const ok = await add(file, false)
-      if (ok) found = true
-    }
-
-    if (!found && files.length > 0 && toast) warn()
-    return found
-  }
-
   const removeAttachment = (id: string) => {
     const current = prompt.current()
     const next = current.filter((part) => part.type !== "image" || part.id !== id)
@@ -97,14 +84,18 @@ export function createPromptAttachments(input: PromptAttachmentsInput) {
     event.preventDefault()
     event.stopPropagation()
 
-    const files = Array.from(clipboardData.items).flatMap((item) => {
+    const items = Array.from(clipboardData.items)
-      if (item.kind !== "file") return []
+    const fileItems = items.filter((item) => item.kind === "file")
-      const file = item.getAsFile()
-      return file ? [file] : []
-    })
 
-    if (files.length > 0) {
+    if (fileItems.length > 0) {
-      await addAttachments(files)
+      let found = false
+      for (const item of fileItems) {
+        const file = item.getAsFile()
+        if (!file) continue
+        const ok = await add(file, false)
+        if (ok) found = true
+      }
+      if (!found) warn()
       return
     }
 
@@ -178,18 +169,28 @@ export function createPromptAttachments(input: PromptAttachmentsInput) {
     const dropped = event.dataTransfer?.files
     if (!dropped) return
 
-    await addAttachments(Array.from(dropped))
+    let found = false
+    for (const file of Array.from(dropped)) {
+      const ok = await add(file, false)
+      if (ok) found = true
+    }
+    if (!found && dropped.length > 0) warn()
   }
 
   onMount(() => {
-    makeEventListener(document, "dragover", handleGlobalDragOver)
+    document.addEventListener("dragover", handleGlobalDragOver)
-    makeEventListener(document, "dragleave", handleGlobalDragLeave)
+    document.addEventListener("dragleave", handleGlobalDragLeave)
-    makeEventListener(document, "drop", handleGlobalDrop)
+    document.addEventListener("drop", handleGlobalDrop)
+  })
+
+  onCleanup(() => {
+    document.removeEventListener("dragover", handleGlobalDragOver)
+    document.removeEventListener("dragleave", handleGlobalDragLeave)
+    document.removeEventListener("drop", handleGlobalDrop)
   })
 
   return {
     addAttachment,
-    addAttachments,
     removeAttachment,
     handlePaste,
   }

packages/app/src/components/prompt-input/build-request-parts.test.ts

@@ -49,32 +49,6 @@ describe("buildRequestParts", () => {
     expect(result.optimisticParts.every((part) => part.sessionID === "ses_1" && part.messageID === "msg_1")).toBe(true)
   })
 
-  test("keeps multiple uploaded attachments in order", () => {
-    const result = buildRequestParts({
-      prompt: [{ type: "text", content: "check these", start: 0, end: 11 }],
-      context: [],
-      images: [
-        { type: "image", id: "img_1", filename: "a.png", mime: "image/png", dataUrl: "data:image/png;base64,AAA" },
-        {
-          type: "image",
-          id: "img_2",
-          filename: "b.pdf",
-          mime: "application/pdf",
-          dataUrl: "data:application/pdf;base64,BBB",
-        },
-      ],
-      text: "check these",
-      messageID: "msg_multi",
-      sessionID: "ses_multi",
-      sessionDirectory: "/repo",
-    })
-
-    const files = result.requestParts.filter((part) => part.type === "file" && part.url.startsWith("data:"))
-
-    expect(files).toHaveLength(2)
-    expect(files.map((part) => (part.type === "file" ? part.filename : ""))).toEqual(["a.png", "b.pdf"])
-  })
-
   test("deduplicates context files when prompt already includes same path", () => {
     const prompt: Prompt = [{ type: "file", path: "src/foo.ts", content: "@src/foo.ts", start: 0, end: 11 }]
 
@@ -100,30 +74,6 @@ describe("buildRequestParts", () => {
     expect(synthetic).toHaveLength(1)
   })
 
-  test("adds file parts for @mentions inside comment text", () => {
-    const result = buildRequestParts({
-      prompt: [{ type: "text", content: "look", start: 0, end: 4 }],
-      context: [
-        {
-          key: "ctx:comment-mention",
-          type: "file",
-          path: "src/review.ts",
-          comment: "Compare with @src/shared.ts and @src/review.ts.",
-        },
-      ],
-      images: [],
-      text: "look",
-      messageID: "msg_comment_mentions",
-      sessionID: "ses_comment_mentions",
-      sessionDirectory: "/repo",
-    })
-
-    const files = result.requestParts.filter((part) => part.type === "file")
-    expect(files).toHaveLength(2)
-    expect(files.some((part) => part.type === "file" && part.url === "file:///repo/src/review.ts")).toBe(true)
-    expect(files.some((part) => part.type === "file" && part.url === "file:///repo/src/shared.ts")).toBe(true)
-  })
-
   test("handles Windows paths correctly (simulated on macOS)", () => {
     const prompt: Prompt = [{ type: "file", path: "src\\foo.ts", content: "@src\\foo.ts", start: 0, end: 11 }]
 

packages/app/src/components/prompt-input/build-request-parts.ts

@@ -39,16 +39,6 @@ const absolute = (directory: string, path: string) => {
 const fileQuery = (selection: FileSelection | undefined) =>
   selection ? `?start=${selection.startLine}&end=${selection.endLine}` : ""
 
-const mention = /(^|[\s([{"'])@(\S+)/g
-
-const parseCommentMentions = (comment: string) => {
-  return Array.from(comment.matchAll(mention)).flatMap((match) => {
-    const path = (match[2] ?? "").replace(/[.,!?;:)}\]"']+$/, "")
-    if (!path) return []
-    return [path]
-  })
-}
-
 const isFileAttachment = (part: Prompt[number]): part is FileAttachmentPart => part.type === "file"
 const isAgentAttachment = (part: Prompt[number]): part is AgentPart => part.type === "agent"
 
@@ -148,21 +138,6 @@ export function buildRequestParts(input: BuildRequestPartsInput) {
 
     if (!comment) return [filePart]
 
-    const mentions = parseCommentMentions(comment).flatMap((path) => {
-      const url = `file://${encodeFilePath(absolute(input.sessionDirectory, path))}`
-      if (used.has(url)) return []
-      used.add(url)
-      return [
-        {
-          id: Identifier.ascending("part"),
-          type: "file",
-          mime: "text/plain",
-          url,
-          filename: getFilename(path),
-        } satisfies PromptRequestPart,
-      ]
-    })
-
     return [
       {
         id: Identifier.ascending("part"),
@@ -178,7 +153,6 @@ export function buildRequestParts(input: BuildRequestPartsInput) {
         }),
       } satisfies PromptRequestPart,
       filePart,
-      ...mentions,
     ]
   })
 

packages/app/src/components/prompt-input/history.test.ts

@@ -126,7 +126,7 @@ describe("prompt-input history", () => {
   test("canNavigateHistoryAtCursor only allows prompt boundaries", () => {
     const value = "a\nb\nc"
 
-    expect(canNavigateHistoryAtCursor("up", value, 0)).toBe(false)
+    expect(canNavigateHistoryAtCursor("up", value, 0)).toBe(true)
     expect(canNavigateHistoryAtCursor("down", value, 0)).toBe(false)
 
     expect(canNavigateHistoryAtCursor("up", value, 2)).toBe(false)
@@ -135,14 +135,11 @@ describe("prompt-input history", () => {
     expect(canNavigateHistoryAtCursor("up", value, 5)).toBe(false)
     expect(canNavigateHistoryAtCursor("down", value, 5)).toBe(true)
 
-    expect(canNavigateHistoryAtCursor("up", "abc", 0)).toBe(false)
+    expect(canNavigateHistoryAtCursor("up", "abc", 0)).toBe(true)
     expect(canNavigateHistoryAtCursor("down", "abc", 3)).toBe(true)
     expect(canNavigateHistoryAtCursor("up", "abc", 1)).toBe(false)
     expect(canNavigateHistoryAtCursor("down", "abc", 1)).toBe(false)
 
-    expect(canNavigateHistoryAtCursor("up", "", 0)).toBe(true)
-    expect(canNavigateHistoryAtCursor("down", "", 0)).toBe(true)
-
     expect(canNavigateHistoryAtCursor("up", "abc", 0, true)).toBe(true)
     expect(canNavigateHistoryAtCursor("up", "abc", 3, true)).toBe(true)
     expect(canNavigateHistoryAtCursor("down", "abc", 0, true)).toBe(true)

packages/app/src/components/prompt-input/history.ts

@@ -27,7 +27,7 @@ export function canNavigateHistoryAtCursor(direction: "up" | "down", text: strin
   const atStart = position === 0
   const atEnd = position === text.length
   if (inHistory) return atStart || atEnd
-  if (direction === "up") return position === 0 && text.length === 0
+  if (direction === "up") return position === 0
   return position === text.length
 }
 

packages/app/src/components/prompt-input/image-attachments.tsx

@@ -1,6 +1,5 @@
 import { Component, For, Show } from "solid-js"
 import { Icon } from "@opencode-ai/ui/icon"
-import { Tooltip } from "@opencode-ai/ui/tooltip"
 import type { ImageAttachmentPart } from "@/context/prompt"
 
 type PromptImageAttachmentsProps = {
@@ -23,36 +22,34 @@ export const PromptImageAttachments: Component<PromptImageAttachmentsProps> = (p
       <div class="flex flex-wrap gap-2 px-3 pt-3">
         <For each={props.attachments}>
           {(attachment) => (
-            <Tooltip value={attachment.filename} placement="top" contentClass="break-all">
+            <div class="relative group">
-              <div class="relative group">
+              <Show
-                <Show
+                when={attachment.mime.startsWith("image/")}
-                  when={attachment.mime.startsWith("image/")}
+                fallback={
-                  fallback={
+                  <div class={fallbackClass}>
-                    <div class={fallbackClass}>
+                    <Icon name="folder" class="size-6 text-text-weak" />
-                      <Icon name="folder" class="size-6 text-text-weak" />
+                  </div>
-                    </div>
+                }
-                  }
+              >
-                >
+                <img
-                  <img
+                  src={attachment.dataUrl}
-                    src={attachment.dataUrl}
+                  alt={attachment.filename}
-                    alt={attachment.filename}
+                  class={imageClass}
-                    class={imageClass}
+                  onClick={() => props.onOpen(attachment)}
-                    onClick={() => props.onOpen(attachment)}
+                />
-                  />
+              </Show>
-                </Show>
+              <button
-                <button
+                type="button"
-                  type="button"
+                onClick={() => props.onRemove(attachment.id)}
-                  onClick={() => props.onRemove(attachment.id)}
+                class={removeClass}
-                  class={removeClass}
+                aria-label={props.removeLabel}
-                  aria-label={props.removeLabel}
+              >
-                >
+                <Icon name="close" class="size-3 text-text-weak" />
-                  <Icon name="close" class="size-3 text-text-weak" />
+              </button>
-                </button>
+              <div class={nameClass}>
-                <div class={nameClass}>
+                <span class="text-10-regular text-white truncate block">{attachment.filename}</span>
-                  <span class="text-10-regular text-white truncate block">{attachment.filename}</span>
-                </div>
               </div>
-            </Tooltip>
+            </div>
           )}
         </For>
       </div>

packages/app/src/components/prompt-input/submit.test.ts

@@ -146,7 +146,7 @@ beforeAll(async () => {
           add: (value: {
             directory?: string
             sessionID?: string
-            message: { agent: string; model: { providerID: string; modelID: string; variant?: string } }
+            message: { agent: string; model: { providerID: string; modelID: string }; variant?: string }
           }) => {
             optimistic.push(value)
             optimisticSeeded.push(
@@ -310,7 +310,8 @@ describe("prompt submit worktree selection", () => {
     expect(optimistic[0]).toMatchObject({
       message: {
         agent: "agent",
-        model: { providerID: "provider", modelID: "model", variant: "high" },
+        model: { providerID: "provider", modelID: "model" },
+        variant: "high",
       },
     })
   })

packages/app/src/components/prompt-input/submit.ts

@@ -13,7 +13,6 @@ import { usePermission } from "@/context/permission"
 import { type ContextItem, type ImageAttachmentPart, type Prompt, usePrompt } from "@/context/prompt"
 import { useSDK } from "@/context/sdk"
 import { useSync } from "@/context/sync"
-import { promptProbe } from "@/testing/prompt"
 import { Identifier } from "@/utils/id"
 import { Worktree as WorktreeState } from "@/utils/worktree"
 import { buildRequestParts } from "./build-request-parts"
@@ -121,7 +120,8 @@ export async function sendFollowupDraft(input: FollowupSendInput) {
     role: "user",
     time: { created: Date.now() },
     agent: input.draft.agent,
-    model: { ...input.draft.model, variant: input.draft.variant },
+    model: input.draft.model,
+    variant: input.draft.variant,
   }
 
   const add = () =>
@@ -307,7 +307,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
 
     input.addToHistory(currentPrompt, mode)
     input.resetHistoryNavigation()
-    promptProbe.start()
 
     const projectDirectory = sdk.directory
     const isNewSession = !params.id
@@ -427,7 +426,6 @@ export function createPromptSubmit(input: PromptSubmitInput) {
       return
     }
 
-    promptProbe.submit({ sessionID: session.id, directory: sessionDirectory })
     input.onSubmit?.()
 
     if (mode === "shell") {

packages/app/src/components/server/server-row.tsx

@@ -1,11 +1,11 @@
 import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { createResizeObserver } from "@solid-primitives/resize-observer"
 import {
   children,
   createEffect,
   createMemo,
   createSignal,
   type JSXElement,
+  onCleanup,
   onMount,
   type ParentProps,
   Show,
@@ -46,9 +46,12 @@ export function ServerRow(props: ServerRowProps) {
   })
 
   onMount(() => {
-    if (typeof ResizeObserver !== "function") return
-    createResizeObserver([nameRef, versionRef], check)
     check()
+    if (typeof ResizeObserver !== "function") return
+    const observer = new ResizeObserver(check)
+    if (nameRef) observer.observe(nameRef)
+    if (versionRef) observer.observe(versionRef)
+    onCleanup(() => observer.disconnect())
   })
 
   const tooltipValue = () => (

packages/app/src/components/session-context-usage.tsx

@@ -7,7 +7,6 @@ import { useFile } from "@/context/file"
 import { useLayout } from "@/context/layout"
 import { useSync } from "@/context/sync"
 import { useLanguage } from "@/context/language"
-import { useProviders } from "@/hooks/use-providers"
 import { getSessionContextMetrics } from "@/components/session/session-context-metrics"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { createSessionTabs } from "@/pages/session/helpers"
@@ -33,7 +32,6 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
   const file = useFile()
   const layout = useLayout()
   const language = useLanguage()
-  const providers = useProviders()
   const { params, tabs, view } = useSessionLayout()
 
   const variant = createMemo(() => props.variant ?? "button")
@@ -52,7 +50,7 @@ export function SessionContextUsage(props: SessionContextUsageProps) {
       }),
   )
 
-  const metrics = createMemo(() => getSessionContextMetrics(messages(), providers.all()))
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), sync.data.provider.all))
   const context = createMemo(() => metrics().context)
   const cost = createMemo(() => {
     return usd().format(metrics().totalCost)

packages/app/src/components/session/session-context-tab.tsx

@@ -12,7 +12,6 @@ import { Markdown } from "@opencode-ai/ui/markdown"
 import { ScrollView } from "@opencode-ai/ui/scroll-view"
 import type { Message, Part, UserMessage } from "@opencode-ai/sdk/v2/client"
 import { useLanguage } from "@/context/language"
-import { useProviders } from "@/hooks/use-providers"
 import { useSessionLayout } from "@/pages/session/session-layout"
 import { getSessionContextMetrics } from "./session-context-metrics"
 import { estimateSessionContextBreakdown, type SessionContextBreakdownKey } from "./session-context-breakdown"
@@ -93,7 +92,6 @@ const emptyUserMessages: UserMessage[] = []
 export function SessionContextTab() {
   const sync = useSync()
   const language = useLanguage()
-  const providers = useProviders()
   const { params, view } = useSessionLayout()
 
   const info = createMemo(() => (params.id ? sync.session.get(params.id) : undefined))
@@ -132,7 +130,7 @@ export function SessionContextTab() {
       }),
   )
 
-  const metrics = createMemo(() => getSessionContextMetrics(messages(), providers.all()))
+  const metrics = createMemo(() => getSessionContextMetrics(messages(), sync.data.provider.all))
   const ctx = createMemo(() => metrics().context)
   const formatter = createMemo(() => createSessionContextFormatter(language.intl()))
 
@@ -269,14 +267,14 @@ export function SessionContextTab() {
 
   return (
     <ScrollView
-      class="@container h-full"
+      class="@container h-full pb-10"
       viewportRef={(el) => {
         scroll = el
         restoreScroll()
       }}
       onScroll={handleScroll}
     >
-      <div class="px-6 pt-4 pb-10 flex flex-col gap-10">
+      <div class="px-6 pt-4 flex flex-col gap-10">
         <div class="grid grid-cols-1 @[32rem]:grid-cols-2 gap-4">
           <For each={stats}>
             {(stat) => <Stat label={language.t(stat.label as Parameters<typeof language.t>[0])} value={stat.value()} />}

packages/app/src/components/session/session-sortable-terminal-tab.tsx

@@ -24,7 +24,6 @@ export function SortableTerminalTab(props: { terminal: LocalPTY; onClose?: () =>
   })
   let input: HTMLInputElement | undefined
   let blurFrame: number | undefined
-  let editRequested = false
 
   const isDefaultTitle = () => {
     const number = props.terminal.titleNumber
@@ -169,14 +168,8 @@ export function SortableTerminalTab(props: { terminal: LocalPTY; onClose?: () =>
                 left: `${store.menuPosition.x}px`,
                 top: `${store.menuPosition.y}px`,
               }}
-              onCloseAutoFocus={(e) => {
-                if (!editRequested) return
-                e.preventDefault()
-                editRequested = false
-                requestAnimationFrame(() => edit())
-              }}
             >
-              <DropdownMenu.Item onSelect={() => (editRequested = true)}>
+              <DropdownMenu.Item onSelect={edit}>
                 <Icon name="edit" class="w-4 h-4 mr-2" />
                 {language.t("common.rename")}
               </DropdownMenu.Item>

packages/app/src/components/settings-general.tsx

@@ -1,46 +1,27 @@
-import { Component, Show, createMemo, createResource, onMount, type JSX } from "solid-js"
+import { Component, Show, createMemo, createResource, type JSX } from "solid-js"
 import { createStore } from "solid-js/store"
 import { Button } from "@opencode-ai/ui/button"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Select } from "@opencode-ai/ui/select"
 import { Switch } from "@opencode-ai/ui/switch"
-import { TextField } from "@opencode-ai/ui/text-field"
 import { Tooltip } from "@opencode-ai/ui/tooltip"
-import { useTheme, type ColorScheme } from "@opencode-ai/ui/theme/context"
+import { useTheme, type ColorScheme } from "@opencode-ai/ui/theme"
 import { showToast } from "@opencode-ai/ui/toast"
-import { useParams } from "@solidjs/router"
 import { useLanguage } from "@/context/language"
-import { usePermission } from "@/context/permission"
 import { usePlatform } from "@/context/platform"
-import {
+import { useSettings, monoFontFamily } from "@/context/settings"
-  monoDefault,
+import { playSound, SOUND_OPTIONS } from "@/utils/sound"
-  monoFontFamily,
-  monoInput,
-  sansDefault,
-  sansFontFamily,
-  sansInput,
-  useSettings,
-} from "@/context/settings"
-import { decode64 } from "@/utils/base64"
-import { playSoundById, SOUND_OPTIONS } from "@/utils/sound"
 import { Link } from "./link"
 import { SettingsList } from "./settings-list"
 
 let demoSoundState = {
   cleanup: undefined as (() => void) | undefined,
   timeout: undefined as NodeJS.Timeout | undefined,
-  run: 0,
-}
-
-type ThemeOption = {
-  id: string
-  name: string
 }
 
 // To prevent audio from overlapping/playing very quickly when navigating the settings menus,
 // delay the playback by 100ms during quick selection changes and pause existing sounds.
 const stopDemoSound = () => {
-  demoSoundState.run += 1
   if (demoSoundState.cleanup) {
     demoSoundState.cleanup()
   }
@@ -48,64 +29,26 @@ const stopDemoSound = () => {
   demoSoundState.cleanup = undefined
 }
 
-const playDemoSound = (id: string | undefined) => {
+const playDemoSound = (src: string | undefined) => {
   stopDemoSound()
-  if (!id) return
+  if (!src) return
 
-  const run = ++demoSoundState.run
   demoSoundState.timeout = setTimeout(() => {
-    void playSoundById(id).then((cleanup) => {
+    demoSoundState.cleanup = playSound(src)
-      if (demoSoundState.run !== run) {
-        cleanup?.()
-        return
-      }
-      demoSoundState.cleanup = cleanup
-    })
   }, 100)
 }
 
 export const SettingsGeneral: Component = () => {
   const theme = useTheme()
   const language = useLanguage()
-  const permission = usePermission()
   const platform = usePlatform()
-  const params = useParams()
   const settings = useSettings()
 
-  onMount(() => {
-    void theme.loadThemes()
-  })
-
   const [store, setStore] = createStore({
     checking: false,
   })
 
   const linux = createMemo(() => platform.platform === "desktop" && platform.os === "linux")
-  const dir = createMemo(() => decode64(params.dir))
-  const accepting = createMemo(() => {
-    const value = dir()
-    if (!value) return false
-    if (!params.id) return permission.isAutoAcceptingDirectory(value)
-    return permission.isAutoAccepting(params.id, value)
-  })
-
-  const toggleAccept = (checked: boolean) => {
-    const value = dir()
-    if (!value) return
-
-    if (!params.id) {
-      if (permission.isAutoAcceptingDirectory(value) === checked) return
-      permission.toggleAutoAcceptDirectory(value)
-      return
-    }
-
-    if (checked) {
-      permission.enableAutoAccept(params.id, value)
-      return
-    }
-
-    permission.disableAutoAccept(params.id, value)
-  }
 
   const check = () => {
     if (!platform.checkUpdate) return
@@ -161,7 +104,9 @@ export const SettingsGeneral: Component = () => {
       .finally(() => setStore("checking", false))
   }
 
-  const themeOptions = createMemo<ThemeOption[]>(() => theme.ids().map((id) => ({ id, name: theme.name(id) })))
+  const themeOptions = createMemo(() =>
+    Object.entries(theme.themes()).map(([id, def]) => ({ id, name: def.name ?? id })),
+  )
 
   const colorSchemeOptions = createMemo((): { value: ColorScheme; label: string }[] => [
     { value: "system", label: language.t("theme.scheme.system") },
@@ -169,6 +114,11 @@ export const SettingsGeneral: Component = () => {
     { value: "dark", label: language.t("theme.scheme.dark") },
   ])
 
+  const followupOptions = createMemo((): { value: "queue" | "steer"; label: string }[] => [
+    { value: "queue", label: language.t("settings.general.row.followup.option.queue") },
+    { value: "steer", label: language.t("settings.general.row.followup.option.steer") },
+  ])
+
   const languageOptions = createMemo(() =>
     language.locales.map((locale) => ({
       value: locale,
@@ -176,10 +126,25 @@ export const SettingsGeneral: Component = () => {
     })),
   )
 
-  const noneSound = { id: "none", label: "sound.option.none" } as const
+  const fontOptions = [
+    { value: "ibm-plex-mono", label: "font.option.ibmPlexMono" },
+    { value: "cascadia-code", label: "font.option.cascadiaCode" },
+    { value: "fira-code", label: "font.option.firaCode" },
+    { value: "hack", label: "font.option.hack" },
+    { value: "inconsolata", label: "font.option.inconsolata" },
+    { value: "intel-one-mono", label: "font.option.intelOneMono" },
+    { value: "iosevka", label: "font.option.iosevka" },
+    { value: "jetbrains-mono", label: "font.option.jetbrainsMono" },
+    { value: "meslo-lgs", label: "font.option.mesloLgs" },
+    { value: "roboto-mono", label: "font.option.robotoMono" },
+    { value: "source-code-pro", label: "font.option.sourceCodePro" },
+    { value: "ubuntu-mono", label: "font.option.ubuntuMono" },
+    { value: "geist-mono", label: "font.option.geistMono" },
+  ] as const
+  const fontOptionsList = [...fontOptions]
+
+  const noneSound = { id: "none", label: "sound.option.none", src: undefined } as const
   const soundOptions = [noneSound, ...SOUND_OPTIONS]
-  const mono = () => monoInput(settings.appearance.font())
-  const sans = () => sansInput(settings.appearance.uiFont())
 
   const soundSelectProps = (
     enabled: () => boolean,
@@ -193,7 +158,7 @@ export const SettingsGeneral: Component = () => {
     label: (o: (typeof soundOptions)[number]) => language.t(o.label),
     onHighlight: (option: (typeof soundOptions)[number] | undefined) => {
       if (!option) return
-      playDemoSound(option.id === "none" ? undefined : option.id)
+      playDemoSound(option.src)
     },
     onSelect: (option: (typeof soundOptions)[number] | undefined) => {
       if (!option) return
@@ -204,7 +169,7 @@ export const SettingsGeneral: Component = () => {
       }
       setEnabled(true)
       set(option.id)
-      playDemoSound(option.id)
+      playDemoSound(option.src)
     },
     variant: "secondary" as const,
     size: "small" as const,
@@ -231,15 +196,6 @@ export const SettingsGeneral: Component = () => {
           />
         </SettingsRow>
 
-        <SettingsRow
-          title={language.t("command.permissions.autoaccept.enable")}
-          description={language.t("toast.permissions.autoaccept.on.description")}
-        >
-          <div data-action="settings-auto-accept-permissions">
-            <Switch checked={accepting()} disabled={!dir()} onChange={toggleAccept} />
-          </div>
-        </SettingsRow>
-
         <SettingsRow
           title={language.t("settings.general.row.reasoningSummaries.title")}
           description={language.t("settings.general.row.reasoningSummaries.description")}
@@ -275,6 +231,24 @@ export const SettingsGeneral: Component = () => {
             />
           </div>
         </SettingsRow>
+
+        <SettingsRow
+          title={language.t("settings.general.row.followup.title")}
+          description={language.t("settings.general.row.followup.description")}
+        >
+          <Select
+            data-action="settings-followup"
+            options={followupOptions()}
+            current={followupOptions().find((o) => o.value === settings.general.followup())}
+            value={(o) => o.value}
+            label={(o) => o.label}
+            onSelect={(option) => option && settings.general.setFollowup(option.value)}
+            variant="secondary"
+            size="small"
+            triggerVariant="settings"
+            triggerStyle={{ "min-width": "180px" }}
+          />
+        </SettingsRow>
       </SettingsList>
     </div>
   )
@@ -337,50 +311,28 @@ export const SettingsGeneral: Component = () => {
           />
         </SettingsRow>
 
-        <SettingsRow
-          title={language.t("settings.general.row.uiFont.title")}
-          description={language.t("settings.general.row.uiFont.description")}
-        >
-          <div class="w-full sm:w-[220px]">
-            <TextField
-              data-action="settings-ui-font"
-              label={language.t("settings.general.row.uiFont.title")}
-              hideLabel
-              type="text"
-              value={sans()}
-              onChange={(value) => settings.appearance.setUIFont(value)}
-              placeholder={sansDefault}
-              spellcheck={false}
-              autocorrect="off"
-              autocomplete="off"
-              autocapitalize="off"
-              class="text-12-regular"
-              style={{ "font-family": sansFontFamily(settings.appearance.uiFont()) }}
-            />
-          </div>
-        </SettingsRow>
-
         <SettingsRow
           title={language.t("settings.general.row.font.title")}
           description={language.t("settings.general.row.font.description")}
         >
-          <div class="w-full sm:w-[220px]">
+          <Select
-            <TextField
+            data-action="settings-font"
-              data-action="settings-code-font"
+            options={fontOptionsList}
-              label={language.t("settings.general.row.font.title")}
+            current={fontOptionsList.find((o) => o.value === settings.appearance.font())}
-              hideLabel
+            value={(o) => o.value}
-              type="text"
+            label={(o) => language.t(o.label)}
-              value={mono()}
+            onSelect={(option) => option && settings.appearance.setFont(option.value)}
-              onChange={(value) => settings.appearance.setFont(value)}
+            variant="secondary"
-              placeholder={monoDefault}
+            size="small"
-              spellcheck={false}
+            triggerVariant="settings"
-              autocorrect="off"
+            triggerStyle={{ "font-family": monoFontFamily(settings.appearance.font()), "min-width": "180px" }}
-              autocomplete="off"
+          >
-              autocapitalize="off"
+            {(option) => (
-              class="text-12-regular"
+              <span style={{ "font-family": monoFontFamily(option?.value) }}>
-              style={{ "font-family": monoFontFamily(settings.appearance.font()) }}
+                {option ? language.t(option.label) : ""}
-            />
+              </span>
-          </div>
+            )}
+          </Select>
         </SettingsRow>
       </SettingsList>
     </div>

packages/app/src/components/settings-keybinds.tsx

@@ -1,6 +1,5 @@
 import { Component, For, Show, createMemo, onCleanup, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
-import { makeEventListener } from "@solid-primitives/event-listener"
 import { Button } from "@opencode-ai/ui/button"
 import { Icon } from "@opencode-ai/ui/icon"
 import { IconButton } from "@opencode-ai/ui/icon-button"
@@ -251,7 +250,8 @@ function useKeyCapture(input: {
       input.stop()
     }
 
-    makeEventListener(document, "keydown", handle, { capture: true })
+    document.addEventListener("keydown", handle, true)
+    onCleanup(() => document.removeEventListener("keydown", handle, true))
   })
 }
 

packages/app/src/components/status-popover-body.tsx

@@ -1,445 +0,0 @@
-import { Button } from "@opencode-ai/ui/button"
-import { useDialog } from "@opencode-ai/ui/context/dialog"
-import { Icon } from "@opencode-ai/ui/icon"
-import { Switch } from "@opencode-ai/ui/switch"
-import { Tabs } from "@opencode-ai/ui/tabs"
-import { useMutation } from "@tanstack/solid-query"
-import { showToast } from "@opencode-ai/ui/toast"
-import { useNavigate } from "@solidjs/router"
-import { type Accessor, createEffect, createMemo, For, type JSXElement, onCleanup, Show } from "solid-js"
-import { createStore, reconcile } from "solid-js/store"
-import { ServerHealthIndicator, ServerRow } from "@/components/server/server-row"
-import { useLanguage } from "@/context/language"
-import { usePlatform } from "@/context/platform"
-import { useSDK } from "@/context/sdk"
-import { normalizeServerUrl, ServerConnection, useServer } from "@/context/server"
-import { useSync } from "@/context/sync"
-import { useCheckServerHealth, type ServerHealth } from "@/utils/server-health"
-
-const pollMs = 10_000
-
-const pluginEmptyMessage = (value: string, file: string): JSXElement => {
-  const parts = value.split(file)
-  if (parts.length === 1) return value
-  return (
-    <>
-      {parts[0]}
-      <code class="bg-surface-raised-base px-1.5 py-0.5 rounded-sm text-text-base">{file}</code>
-      {parts.slice(1).join(file)}
-    </>
-  )
-}
-
-const listServersByHealth = (
-  list: ServerConnection.Any[],
-  active: ServerConnection.Key | undefined,
-  status: Record<ServerConnection.Key, ServerHealth | undefined>,
-) => {
-  if (!list.length) return list
-  const order = new Map(list.map((url, index) => [url, index] as const))
-  const rank = (value?: ServerHealth) => {
-    if (value?.healthy === true) return 0
-    if (value?.healthy === false) return 2
-    return 1
-  }
-
-  return list.slice().sort((a, b) => {
-    if (ServerConnection.key(a) === active) return -1
-    if (ServerConnection.key(b) === active) return 1
-    const diff = rank(status[ServerConnection.key(a)]) - rank(status[ServerConnection.key(b)])
-    if (diff !== 0) return diff
-    return (order.get(a) ?? 0) - (order.get(b) ?? 0)
-  })
-}
-
-const useServerHealth = (servers: Accessor<ServerConnection.Any[]>, enabled: Accessor<boolean>) => {
-  const checkServerHealth = useCheckServerHealth()
-  const [status, setStatus] = createStore({} as Record<ServerConnection.Key, ServerHealth | undefined>)
-
-  createEffect(() => {
-    if (!enabled()) {
-      setStatus(reconcile({}))
-      return
-    }
-    const list = servers()
-    let dead = false
-
-    const refresh = async () => {
-      const results: Record<string, ServerHealth> = {}
-      await Promise.all(
-        list.map(async (conn) => {
-          results[ServerConnection.key(conn)] = await checkServerHealth(conn.http)
-        }),
-      )
-      if (dead) return
-      setStatus(reconcile(results))
-    }
-
-    void refresh()
-    const id = setInterval(() => void refresh(), pollMs)
-    onCleanup(() => {
-      dead = true
-      clearInterval(id)
-    })
-  })
-
-  return status
-}
-
-const useDefaultServerKey = (
-  get: (() => string | Promise<string | null | undefined> | null | undefined) | undefined,
-) => {
-  const [state, setState] = createStore({
-    url: undefined as string | undefined,
-    tick: 0,
-  })
-
-  createEffect(() => {
-    state.tick
-    let dead = false
-    const result = get?.()
-    if (!result) {
-      setState("url", undefined)
-      onCleanup(() => {
-        dead = true
-      })
-      return
-    }
-
-    if (result instanceof Promise) {
-      void result.then((next) => {
-        if (dead) return
-        setState("url", next ? normalizeServerUrl(next) : undefined)
-      })
-      onCleanup(() => {
-        dead = true
-      })
-      return
-    }
-
-    setState("url", normalizeServerUrl(result))
-    onCleanup(() => {
-      dead = true
-    })
-  })
-
-  return {
-    key: () => {
-      const u = state.url
-      if (!u) return
-      return ServerConnection.key({ type: "http", http: { url: u } })
-    },
-    refresh: () => setState("tick", (value) => value + 1),
-  }
-}
-
-const useMcpToggleMutation = () => {
-  const sync = useSync()
-  const sdk = useSDK()
-  const language = useLanguage()
-
-  return useMutation(() => ({
-    mutationFn: async (name: string) => {
-      const status = sync.data.mcp[name]
-      await (status?.status === "connected" ? sdk.client.mcp.disconnect({ name }) : sdk.client.mcp.connect({ name }))
-      const result = await sdk.client.mcp.status()
-      if (result.data) sync.set("mcp", result.data)
-    },
-    onError: (err) => {
-      showToast({
-        variant: "error",
-        title: language.t("common.requestFailed"),
-        description: err instanceof Error ? err.message : String(err),
-      })
-    },
-  }))
-}
-
-export function StatusPopoverBody(props: { shown: Accessor<boolean> }) {
-  const sync = useSync()
-  const server = useServer()
-  const platform = usePlatform()
-  const dialog = useDialog()
-  const language = useLanguage()
-  const navigate = useNavigate()
-  const sdk = useSDK()
-
-  const [load, setLoad] = createStore({
-    lspDone: false,
-    lspLoading: false,
-    mcpDone: false,
-    mcpLoading: false,
-  })
-
-  const fail = (err: unknown) => {
-    showToast({
-      variant: "error",
-      title: language.t("common.requestFailed"),
-      description: err instanceof Error ? err.message : String(err),
-    })
-  }
-
-  createEffect(() => {
-    if (!props.shown()) return
-
-    if (!sync.data.mcp_ready && !load.mcpDone && !load.mcpLoading) {
-      setLoad("mcpLoading", true)
-      void sdk.client.mcp
-        .status()
-        .then((result) => {
-          sync.set("mcp", result.data ?? {})
-          sync.set("mcp_ready", true)
-        })
-        .catch((err) => {
-          setLoad("mcpDone", true)
-          fail(err)
-        })
-        .finally(() => {
-          setLoad("mcpLoading", false)
-        })
-    }
-
-    if (!sync.data.lsp_ready && !load.lspDone && !load.lspLoading) {
-      setLoad("lspLoading", true)
-      void sdk.client.lsp
-        .status()
-        .then((result) => {
-          sync.set("lsp", result.data ?? [])
-          sync.set("lsp_ready", true)
-        })
-        .catch((err) => {
-          setLoad("lspDone", true)
-          fail(err)
-        })
-        .finally(() => {
-          setLoad("lspLoading", false)
-        })
-    }
-  })
-
-  let dialogRun = 0
-  let dialogDead = false
-  onCleanup(() => {
-    dialogDead = true
-    dialogRun += 1
-  })
-  const servers = createMemo(() => {
-    const current = server.current
-    const list = server.list
-    if (!current) return list
-    if (list.every((item) => ServerConnection.key(item) !== ServerConnection.key(current))) return [current, ...list]
-    return [current, ...list.filter((item) => ServerConnection.key(item) !== ServerConnection.key(current))]
-  })
-  const health = useServerHealth(servers, props.shown)
-  const sortedServers = createMemo(() => listServersByHealth(servers(), server.key, health))
-  const toggleMcp = useMcpToggleMutation()
-  const defaultServer = useDefaultServerKey(platform.getDefaultServer)
-  const mcpNames = createMemo(() => Object.keys(sync.data.mcp ?? {}).sort((a, b) => a.localeCompare(b)))
-  const mcpStatus = (name: string) => sync.data.mcp?.[name]?.status
-  const mcpConnected = createMemo(() => mcpNames().filter((name) => mcpStatus(name) === "connected").length)
-  const lspItems = createMemo(() => sync.data.lsp ?? [])
-  const lspCount = createMemo(() => lspItems().length)
-  const plugins = createMemo(() =>
-    (sync.data.config.plugin ?? []).map((item) => (typeof item === "string" ? item : item[0])),
-  )
-  const pluginCount = createMemo(() => plugins().length)
-  const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
-
-  return (
-    <div class="flex items-center gap-1 w-[360px] rounded-xl shadow-[var(--shadow-lg-border-base)]">
-      <Tabs
-        aria-label={language.t("status.popover.ariaLabel")}
-        class="tabs bg-background-strong rounded-xl overflow-hidden"
-        data-component="tabs"
-        data-active="servers"
-        defaultValue="servers"
-        variant="alt"
-      >
-        <Tabs.List data-slot="tablist" class="bg-transparent border-b-0 px-4 pt-2 pb-0 gap-4 h-10">
-          <Tabs.Trigger value="servers" data-slot="tab" class="text-12-regular">
-            {sortedServers().length > 0 ? `${sortedServers().length} ` : ""}
-            {language.t("status.popover.tab.servers")}
-          </Tabs.Trigger>
-          <Tabs.Trigger value="mcp" data-slot="tab" class="text-12-regular">
-            {mcpConnected() > 0 ? `${mcpConnected()} ` : ""}
-            {language.t("status.popover.tab.mcp")}
-          </Tabs.Trigger>
-          <Tabs.Trigger value="lsp" data-slot="tab" class="text-12-regular">
-            {lspCount() > 0 ? `${lspCount()} ` : ""}
-            {language.t("status.popover.tab.lsp")}
-          </Tabs.Trigger>
-          <Tabs.Trigger value="plugins" data-slot="tab" class="text-12-regular">
-            {pluginCount() > 0 ? `${pluginCount()} ` : ""}
-            {language.t("status.popover.tab.plugins")}
-          </Tabs.Trigger>
-        </Tabs.List>
-
-        <Tabs.Content value="servers">
-          <div class="flex flex-col px-2 pb-2">
-            <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-              <For each={sortedServers()}>
-                {(s) => {
-                  const key = ServerConnection.key(s)
-                  const blocked = () => health[key]?.healthy === false
-                  return (
-                    <button
-                      type="button"
-                      class="flex items-center gap-2 w-full h-8 pl-3 pr-1.5 py-1.5 rounded-md transition-colors text-left"
-                      classList={{
-                        "hover:bg-surface-raised-base-hover": !blocked(),
-                        "cursor-not-allowed": blocked(),
-                      }}
-                      aria-disabled={blocked()}
-                      onClick={() => {
-                        if (blocked()) return
-                        navigate("/")
-                        queueMicrotask(() => server.setActive(key))
-                      }}
-                    >
-                      <ServerHealthIndicator health={health[key]} />
-                      <ServerRow
-                        conn={s}
-                        dimmed={blocked()}
-                        status={health[key]}
-                        class="flex items-center gap-2 w-full min-w-0"
-                        nameClass="text-14-regular text-text-base truncate"
-                        versionClass="text-12-regular text-text-weak truncate"
-                        badge={
-                          <Show when={key === defaultServer.key()}>
-                            <span class="text-11-regular text-text-base bg-surface-base px-1.5 py-0.5 rounded-md">
-                              {language.t("common.default")}
-                            </span>
-                          </Show>
-                        }
-                      >
-                        <div class="flex-1" />
-                        <Show when={server.current && key === ServerConnection.key(server.current)}>
-                          <Icon name="check" size="small" class="text-icon-weak shrink-0" />
-                        </Show>
-                      </ServerRow>
-                    </button>
-                  )
-                }}
-              </For>
-
-              <Button
-                variant="secondary"
-                class="mt-3 self-start h-8 px-3 py-1.5"
-                onClick={() => {
-                  const run = ++dialogRun
-                  void import("./dialog-select-server").then((x) => {
-                    if (dialogDead || dialogRun !== run) return
-                    dialog.show(() => <x.DialogSelectServer />, defaultServer.refresh)
-                  })
-                }}
-              >
-                {language.t("status.popover.action.manageServers")}
-              </Button>
-            </div>
-          </div>
-        </Tabs.Content>
-
-        <Tabs.Content value="mcp">
-          <div class="flex flex-col px-2 pb-2">
-            <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-              <Show
-                when={mcpNames().length > 0}
-                fallback={
-                  <div class="text-14-regular text-text-base text-center my-auto">{language.t("dialog.mcp.empty")}</div>
-                }
-              >
-                <For each={mcpNames()}>
-                  {(name) => {
-                    const status = () => mcpStatus(name)
-                    const enabled = () => status() === "connected"
-                    return (
-                      <button
-                        type="button"
-                        class="flex items-center gap-2 w-full h-8 pl-3 pr-2 py-1 rounded-md hover:bg-surface-raised-base-hover transition-colors text-left"
-                        onClick={() => {
-                          if (toggleMcp.isPending) return
-                          toggleMcp.mutate(name)
-                        }}
-                        disabled={toggleMcp.isPending && toggleMcp.variables === name}
-                      >
-                        <div
-                          classList={{
-                            "size-1.5 rounded-full shrink-0": true,
-                            "bg-icon-success-base": status() === "connected",
-                            "bg-icon-critical-base": status() === "failed",
-                            "bg-border-weak-base": status() === "disabled",
-                            "bg-icon-warning-base":
-                              status() === "needs_auth" || status() === "needs_client_registration",
-                          }}
-                        />
-                        <span class="text-14-regular text-text-base truncate flex-1">{name}</span>
-                        <div onClick={(event) => event.stopPropagation()}>
-                          <Switch
-                            checked={enabled()}
-                            disabled={toggleMcp.isPending && toggleMcp.variables === name}
-                            onChange={() => {
-                              if (toggleMcp.isPending) return
-                              toggleMcp.mutate(name)
-                            }}
-                          />
-                        </div>
-                      </button>
-                    )
-                  }}
-                </For>
-              </Show>
-            </div>
-          </div>
-        </Tabs.Content>
-
-        <Tabs.Content value="lsp">
-          <div class="flex flex-col px-2 pb-2">
-            <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-              <Show
-                when={lspItems().length > 0}
-                fallback={
-                  <div class="text-14-regular text-text-base text-center my-auto">{language.t("dialog.lsp.empty")}</div>
-                }
-              >
-                <For each={lspItems()}>
-                  {(item) => (
-                    <div class="flex items-center gap-2 w-full px-2 py-1">
-                      <div
-                        classList={{
-                          "size-1.5 rounded-full shrink-0": true,
-                          "bg-icon-success-base": item.status === "connected",
-                          "bg-icon-critical-base": item.status === "error",
-                        }}
-                      />
-                      <span class="text-14-regular text-text-base truncate">{item.name || item.id}</span>
-                    </div>
-                  )}
-                </For>
-              </Show>
-            </div>
-          </div>
-        </Tabs.Content>
-
-        <Tabs.Content value="plugins">
-          <div class="flex flex-col px-2 pb-2">
-            <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
-              <Show
-                when={plugins().length > 0}
-                fallback={<div class="text-14-regular text-text-base text-center my-auto">{pluginEmpty()}</div>}
-              >
-                <For each={plugins()}>
-                  {(plugin) => (
-                    <div class="flex items-center gap-2 w-full px-2 py-1">
-                      <div class="size-1.5 rounded-full shrink-0 bg-icon-success-base" />
-                      <span class="text-14-regular text-text-base truncate">{plugin}</span>
-                    </div>
-                  )}
-                </For>
-              </Show>
-            </div>
-          </div>
-        </Tabs.Content>
-      </Tabs>
-    </div>
-  )
-}

packages/app/src/components/status-popover.tsx

@@ -1,24 +1,203 @@
 import { Button } from "@opencode-ai/ui/button"
+import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Popover } from "@opencode-ai/ui/popover"
-import { Suspense, createMemo, createSignal, lazy, Show } from "solid-js"
+import { Switch } from "@opencode-ai/ui/switch"
+import { Tabs } from "@opencode-ai/ui/tabs"
+import { showToast } from "@opencode-ai/ui/toast"
+import { useNavigate } from "@solidjs/router"
+import { type Accessor, createEffect, createMemo, createSignal, For, type JSXElement, onCleanup, Show } from "solid-js"
+import { createStore, reconcile } from "solid-js/store"
+import { ServerHealthIndicator, ServerRow } from "@/components/server/server-row"
 import { useLanguage } from "@/context/language"
-import { useServer } from "@/context/server"
+import { usePlatform } from "@/context/platform"
+import { useSDK } from "@/context/sdk"
+import { normalizeServerUrl, ServerConnection, useServer } from "@/context/server"
 import { useSync } from "@/context/sync"
+import { useCheckServerHealth, type ServerHealth } from "@/utils/server-health"
+import { DialogSelectServer } from "./dialog-select-server"
 
-const Body = lazy(() => import("./status-popover-body").then((x) => ({ default: x.StatusPopoverBody })))
+const pollMs = 10_000
+
+const pluginEmptyMessage = (value: string, file: string): JSXElement => {
+  const parts = value.split(file)
+  if (parts.length === 1) return value
+  return (
+    <>
+      {parts[0]}
+      <code class="bg-surface-raised-base px-1.5 py-0.5 rounded-sm text-text-base">{file}</code>
+      {parts.slice(1).join(file)}
+    </>
+  )
+}
+
+const listServersByHealth = (
+  list: ServerConnection.Any[],
+  active: ServerConnection.Key | undefined,
+  status: Record<ServerConnection.Key, ServerHealth | undefined>,
+) => {
+  if (!list.length) return list
+  const order = new Map(list.map((url, index) => [url, index] as const))
+  const rank = (value?: ServerHealth) => {
+    if (value?.healthy === true) return 0
+    if (value?.healthy === false) return 2
+    return 1
+  }
+
+  return list.slice().sort((a, b) => {
+    if (ServerConnection.key(a) === active) return -1
+    if (ServerConnection.key(b) === active) return 1
+    const diff = rank(status[ServerConnection.key(a)]) - rank(status[ServerConnection.key(b)])
+    if (diff !== 0) return diff
+    return (order.get(a) ?? 0) - (order.get(b) ?? 0)
+  })
+}
+
+const useServerHealth = (servers: Accessor<ServerConnection.Any[]>) => {
+  const checkServerHealth = useCheckServerHealth()
+  const [status, setStatus] = createStore({} as Record<ServerConnection.Key, ServerHealth | undefined>)
+
+  createEffect(() => {
+    const list = servers()
+    let dead = false
+
+    const refresh = async () => {
+      const results: Record<string, ServerHealth> = {}
+      await Promise.all(
+        list.map(async (conn) => {
+          results[ServerConnection.key(conn)] = await checkServerHealth(conn.http)
+        }),
+      )
+      if (dead) return
+      setStatus(reconcile(results))
+    }
+
+    void refresh()
+    const id = setInterval(() => void refresh(), pollMs)
+    onCleanup(() => {
+      dead = true
+      clearInterval(id)
+    })
+  })
+
+  return status
+}
+
+const useDefaultServerKey = (
+  get: (() => string | Promise<string | null | undefined> | null | undefined) | undefined,
+) => {
+  const [state, setState] = createStore({
+    url: undefined as string | undefined,
+    tick: 0,
+  })
+
+  createEffect(() => {
+    state.tick
+    let dead = false
+    const result = get?.()
+    if (!result) {
+      setState("url", undefined)
+      onCleanup(() => {
+        dead = true
+      })
+      return
+    }
+
+    if (result instanceof Promise) {
+      void result.then((next) => {
+        if (dead) return
+        setState("url", next ? normalizeServerUrl(next) : undefined)
+      })
+      onCleanup(() => {
+        dead = true
+      })
+      return
+    }
+
+    setState("url", normalizeServerUrl(result))
+    onCleanup(() => {
+      dead = true
+    })
+  })
+
+  return {
+    key: () => {
+      const u = state.url
+      if (!u) return
+      return ServerConnection.key({ type: "http", http: { url: u } })
+    },
+    refresh: () => setState("tick", (value) => value + 1),
+  }
+}
+
+const useMcpToggle = (input: {
+  sync: ReturnType<typeof useSync>
+  sdk: ReturnType<typeof useSDK>
+  language: ReturnType<typeof useLanguage>
+}) => {
+  const [loading, setLoading] = createSignal<string | null>(null)
+
+  const toggle = async (name: string) => {
+    if (loading()) return
+    setLoading(name)
+
+    try {
+      const status = input.sync.data.mcp[name]
+      await (status?.status === "connected"
+        ? input.sdk.client.mcp.disconnect({ name })
+        : input.sdk.client.mcp.connect({ name }))
+      const result = await input.sdk.client.mcp.status()
+      if (result.data) input.sync.set("mcp", result.data)
+    } catch (err) {
+      showToast({
+        variant: "error",
+        title: input.language.t("common.requestFailed"),
+        description: err instanceof Error ? err.message : String(err),
+      })
+    } finally {
+      setLoading(null)
+    }
+  }
+
+  return { loading, toggle }
+}
 
 export function StatusPopover() {
-  const language = useLanguage()
-  const server = useServer()
   const sync = useSync()
+  const sdk = useSDK()
+  const server = useServer()
+  const platform = usePlatform()
+  const dialog = useDialog()
+  const language = useLanguage()
+  const navigate = useNavigate()
+
   const [shown, setShown] = createSignal(false)
-  const ready = createMemo(() => server.healthy() === false || sync.data.mcp_ready)
+  const servers = createMemo(() => {
-  const healthy = createMemo(() => {
+    const current = server.current
+    const list = server.list
+    if (!current) return list
+    if (list.every((item) => ServerConnection.key(item) !== ServerConnection.key(current))) return [current, ...list]
+    return [current, ...list.filter((item) => ServerConnection.key(item) !== ServerConnection.key(current))]
+  })
+  const health = useServerHealth(servers)
+  const sortedServers = createMemo(() => listServersByHealth(servers(), server.key, health))
+  const mcp = useMcpToggle({ sync, sdk, language })
+  const defaultServer = useDefaultServerKey(platform.getDefaultServer)
+  const mcpNames = createMemo(() => Object.keys(sync.data.mcp ?? {}).sort((a, b) => a.localeCompare(b)))
+  const mcpStatus = (name: string) => sync.data.mcp?.[name]?.status
+  const mcpConnected = createMemo(() => mcpNames().filter((name) => mcpStatus(name) === "connected").length)
+  const lspItems = createMemo(() => sync.data.lsp ?? [])
+  const lspCount = createMemo(() => lspItems().length)
+  const plugins = createMemo(() => sync.data.config.plugin ?? [])
+  const pluginCount = createMemo(() => plugins().length)
+  const pluginEmpty = createMemo(() => pluginEmptyMessage(language.t("dialog.plugins.empty"), "opencode.json"))
+  const overallHealthy = createMemo(() => {
     const serverHealthy = server.healthy() === true
-    const mcp = Object.values(sync.data.mcp ?? {})
+    const anyMcpIssue = mcpNames().some((name) => {
-    const issue = mcp.some((item) => item.status !== "connected" && item.status !== "disabled")
+      const status = mcpStatus(name)
-    return serverHealthy && !issue
+      return status !== "connected" && status !== "disabled"
+    })
+    return serverHealthy && !anyMcpIssue
   })
 
   return (
@@ -40,9 +219,9 @@ export function StatusPopover() {
           <div
             classList={{
               "absolute -top-px -right-px size-1.5 rounded-full": true,
-              "bg-icon-success-base": ready() && healthy(),
+              "bg-icon-success-base": overallHealthy(),
-              "bg-icon-critical-base": server.healthy() === false || (ready() && !healthy()),
+              "bg-icon-critical-base": !overallHealthy() && server.healthy() !== undefined,
-              "bg-border-weak-base": server.healthy() === undefined || !ready(),
+              "bg-border-weak-base": server.healthy() === undefined,
             }}
           />
         </div>
@@ -52,15 +231,193 @@ export function StatusPopover() {
       placement="bottom-end"
       shift={-168}
     >
-      <Show when={shown()}>
+      <div class="flex items-center gap-1 w-[360px] rounded-xl shadow-[var(--shadow-lg-border-base)]">
-        <Suspense
+        <Tabs
-          fallback={
+          aria-label={language.t("status.popover.ariaLabel")}
-            <div class="w-[360px] h-14 rounded-xl bg-background-strong shadow-[var(--shadow-lg-border-base)]" />
+          class="tabs bg-background-strong rounded-xl overflow-hidden"
-          }
+          data-component="tabs"
+          data-active="servers"
+          defaultValue="servers"
+          variant="alt"
         >
-          <Body shown={shown} />
+          <Tabs.List data-slot="tablist" class="bg-transparent border-b-0 px-4 pt-2 pb-0 gap-4 h-10">
-        </Suspense>
+            <Tabs.Trigger value="servers" data-slot="tab" class="text-12-regular">
-      </Show>
+              {sortedServers().length > 0 ? `${sortedServers().length} ` : ""}
+              {language.t("status.popover.tab.servers")}
+            </Tabs.Trigger>
+            <Tabs.Trigger value="mcp" data-slot="tab" class="text-12-regular">
+              {mcpConnected() > 0 ? `${mcpConnected()} ` : ""}
+              {language.t("status.popover.tab.mcp")}
+            </Tabs.Trigger>
+            <Tabs.Trigger value="lsp" data-slot="tab" class="text-12-regular">
+              {lspCount() > 0 ? `${lspCount()} ` : ""}
+              {language.t("status.popover.tab.lsp")}
+            </Tabs.Trigger>
+            <Tabs.Trigger value="plugins" data-slot="tab" class="text-12-regular">
+              {pluginCount() > 0 ? `${pluginCount()} ` : ""}
+              {language.t("status.popover.tab.plugins")}
+            </Tabs.Trigger>
+          </Tabs.List>
+
+          <Tabs.Content value="servers">
+            <div class="flex flex-col px-2 pb-2">
+              <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
+                <For each={sortedServers()}>
+                  {(s) => {
+                    const key = ServerConnection.key(s)
+                    const isBlocked = () => health[key]?.healthy === false
+                    return (
+                      <button
+                        type="button"
+                        class="flex items-center gap-2 w-full h-8 pl-3 pr-1.5 py-1.5 rounded-md transition-colors text-left"
+                        classList={{
+                          "hover:bg-surface-raised-base-hover": !isBlocked(),
+                          "cursor-not-allowed": isBlocked(),
+                        }}
+                        aria-disabled={isBlocked()}
+                        onClick={() => {
+                          if (isBlocked()) return
+                          navigate("/")
+                          queueMicrotask(() => server.setActive(key))
+                        }}
+                      >
+                        <ServerHealthIndicator health={health[key]} />
+                        <ServerRow
+                          conn={s}
+                          dimmed={isBlocked()}
+                          status={health[key]}
+                          class="flex items-center gap-2 w-full min-w-0"
+                          nameClass="text-14-regular text-text-base truncate"
+                          versionClass="text-12-regular text-text-weak truncate"
+                          badge={
+                            <Show when={key === defaultServer.key()}>
+                              <span class="text-11-regular text-text-base bg-surface-base px-1.5 py-0.5 rounded-md">
+                                {language.t("common.default")}
+                              </span>
+                            </Show>
+                          }
+                        >
+                          <div class="flex-1" />
+                          <Show when={server.current && key === ServerConnection.key(server.current)}>
+                            <Icon name="check" size="small" class="text-icon-weak shrink-0" />
+                          </Show>
+                        </ServerRow>
+                      </button>
+                    )
+                  }}
+                </For>
+
+                <Button
+                  variant="secondary"
+                  class="mt-3 self-start h-8 px-3 py-1.5"
+                  onClick={() => dialog.show(() => <DialogSelectServer />, defaultServer.refresh)}
+                >
+                  {language.t("status.popover.action.manageServers")}
+                </Button>
+              </div>
+            </div>
+          </Tabs.Content>
+
+          <Tabs.Content value="mcp">
+            <div class="flex flex-col px-2 pb-2">
+              <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
+                <Show
+                  when={mcpNames().length > 0}
+                  fallback={
+                    <div class="text-14-regular text-text-base text-center my-auto">
+                      {language.t("dialog.mcp.empty")}
+                    </div>
+                  }
+                >
+                  <For each={mcpNames()}>
+                    {(name) => {
+                      const status = () => mcpStatus(name)
+                      const enabled = () => status() === "connected"
+                      return (
+                        <button
+                          type="button"
+                          class="flex items-center gap-2 w-full h-8 pl-3 pr-2 py-1 rounded-md hover:bg-surface-raised-base-hover transition-colors text-left"
+                          onClick={() => mcp.toggle(name)}
+                          disabled={mcp.loading() === name}
+                        >
+                          <div
+                            classList={{
+                              "size-1.5 rounded-full shrink-0": true,
+                              "bg-icon-success-base": status() === "connected",
+                              "bg-icon-critical-base": status() === "failed",
+                              "bg-border-weak-base": status() === "disabled",
+                              "bg-icon-warning-base":
+                                status() === "needs_auth" || status() === "needs_client_registration",
+                            }}
+                          />
+                          <span class="text-14-regular text-text-base truncate flex-1">{name}</span>
+                          <div onClick={(event) => event.stopPropagation()}>
+                            <Switch
+                              checked={enabled()}
+                              disabled={mcp.loading() === name}
+                              onChange={() => mcp.toggle(name)}
+                            />
+                          </div>
+                        </button>
+                      )
+                    }}
+                  </For>
+                </Show>
+              </div>
+            </div>
+          </Tabs.Content>
+
+          <Tabs.Content value="lsp">
+            <div class="flex flex-col px-2 pb-2">
+              <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
+                <Show
+                  when={lspItems().length > 0}
+                  fallback={
+                    <div class="text-14-regular text-text-base text-center my-auto">
+                      {language.t("dialog.lsp.empty")}
+                    </div>
+                  }
+                >
+                  <For each={lspItems()}>
+                    {(item) => (
+                      <div class="flex items-center gap-2 w-full px-2 py-1">
+                        <div
+                          classList={{
+                            "size-1.5 rounded-full shrink-0": true,
+                            "bg-icon-success-base": item.status === "connected",
+                            "bg-icon-critical-base": item.status === "error",
+                          }}
+                        />
+                        <span class="text-14-regular text-text-base truncate">{item.name || item.id}</span>
+                      </div>
+                    )}
+                  </For>
+                </Show>
+              </div>
+            </div>
+          </Tabs.Content>
+
+          <Tabs.Content value="plugins">
+            <div class="flex flex-col px-2 pb-2">
+              <div class="flex flex-col p-3 bg-background-base rounded-sm min-h-14">
+                <Show
+                  when={plugins().length > 0}
+                  fallback={<div class="text-14-regular text-text-base text-center my-auto">{pluginEmpty()}</div>}
+                >
+                  <For each={plugins()}>
+                    {(plugin) => (
+                      <div class="flex items-center gap-2 w-full px-2 py-1">
+                        <div class="size-1.5 rounded-full shrink-0 bg-icon-success-base" />
+                        <span class="text-14-regular text-text-base truncate">{plugin}</span>
+                      </div>
+                    )}
+                  </For>
+                </Show>
+              </div>
+            </div>
+          </Tabs.Content>
+        </Tabs>
+      </div>
     </Popover>
   )
 }

packages/app/src/components/terminal.tsx

@@ -1,7 +1,4 @@
-import { withAlpha } from "@opencode-ai/ui/theme/color"
+import { type HexColor, resolveThemeVariant, useTheme, withAlpha } from "@opencode-ai/ui/theme"
-import { useTheme } from "@opencode-ai/ui/theme/context"
-import { resolveThemeVariant } from "@opencode-ai/ui/theme/resolve"
-import type { HexColor } from "@opencode-ai/ui/theme/types"
 import { showToast } from "@opencode-ai/ui/toast"
 import type { FitAddon, Ghostty, Terminal as Term } from "ghostty-web"
 import { type ComponentProps, createEffect, createMemo, onCleanup, onMount, splitProps } from "solid-js"
@@ -174,7 +171,6 @@ export const Terminal = (props: TerminalProps) => {
   const auth = server.current?.http
   const username = auth?.username ?? "opencode"
   const password = auth?.password ?? ""
-  const sameOrigin = new URL(url, location.href).origin === location.origin
   let container!: HTMLDivElement
   const [local, others] = splitProps(props, ["pty", "class", "classList", "autoFocus", "onConnect", "onConnectError"])
   const id = local.pty.id
@@ -520,12 +516,8 @@ export const Terminal = (props: TerminalProps) => {
         next.searchParams.set("directory", directory)
         next.searchParams.set("cursor", String(seek))
         next.protocol = next.protocol === "https:" ? "wss:" : "ws:"
-        if (!sameOrigin && password) {
+        next.username = username
-          next.searchParams.set("auth_token", btoa(`${username}:${password}`))
+        next.password = password
-          // For same-origin requests, let the browser reuse the page's existing auth.
-          next.username = username
-          next.password = password
-        }
 
         const socket = new WebSocket(next)
         socket.binaryType = "arraybuffer"

packages/app/src/components/titlebar.tsx

@@ -5,7 +5,7 @@ import { IconButton } from "@opencode-ai/ui/icon-button"
 import { Icon } from "@opencode-ai/ui/icon"
 import { Button } from "@opencode-ai/ui/button"
 import { Tooltip, TooltipKeybind } from "@opencode-ai/ui/tooltip"
-import { useTheme } from "@opencode-ai/ui/theme/context"
+import { useTheme } from "@opencode-ai/ui/theme"
 
 import { useLayout } from "@/context/layout"
 import { usePlatform } from "@/context/platform"

packages/app/src/context/command-keybind.test.ts

@@ -32,25 +32,6 @@ describe("command keybind helpers", () => {
     expect(matchKeybind(keybinds, new KeyboardEvent("keydown", { key: ",", ctrlKey: true, altKey: true }))).toBe(false)
   })
 
-  test("matchKeybind supports bracket keys", () => {
-    const keybinds = parseKeybind("mod+alt+[, mod+alt+]")
-    const prev = keybinds[0]
-    const next = keybinds[1]
-
-    expect(
-      matchKeybind(
-        keybinds,
-        new KeyboardEvent("keydown", { key: "[", ctrlKey: prev?.ctrl, metaKey: prev?.meta, altKey: true }),
-      ),
-    ).toBe(true)
-    expect(
-      matchKeybind(
-        keybinds,
-        new KeyboardEvent("keydown", { key: "]", ctrlKey: next?.ctrl, metaKey: next?.meta, altKey: true }),
-      ),
-    ).toBe(true)
-  })
-
   test("formatKeybind returns human readable output", () => {
     const display = formatKeybind("ctrl+alt+arrowup")
 
@@ -59,11 +40,4 @@ describe("command keybind helpers", () => {
     expect(display.includes("Alt") || display.includes("⌥")).toBe(true)
     expect(formatKeybind("none")).toBe("")
   })
-
-  test("formatKeybind prefers the first combo", () => {
-    const display = formatKeybind("mod+k,mod+p")
-
-    expect(display.includes("K") || display.includes("k")).toBe(true)
-    expect(display.includes("P") || display.includes("p")).toBe(false)
-  })
 })

packages/app/src/context/command.tsx

@@ -2,7 +2,6 @@ import { createSimpleContext } from "@opencode-ai/ui/context"
 import { useDialog } from "@opencode-ai/ui/context/dialog"
 import { type Accessor, createEffect, createMemo, onCleanup, onMount } from "solid-js"
 import { createStore } from "solid-js/store"
-import { makeEventListener } from "@solid-primitives/event-listener"
 import { useLanguage } from "@/context/language"
 import { useSettings } from "@/context/settings"
 import { dict as en } from "@/i18n/en"
@@ -379,7 +378,11 @@ export const { use: useCommand, provider: CommandProvider } = createSimpleContex
     }
 
     onMount(() => {
-      makeEventListener(document, "keydown", handleKeyDown)
+      document.addEventListener("keydown", handleKeyDown)
+    })
+
+    onCleanup(() => {
+      document.removeEventListener("keydown", handleKeyDown)
     })
 
     function register(cb: () => CommandOption[]): void

packages/app/src/context/global-sdk.tsx

@@ -1,8 +1,7 @@
 import type { Event } from "@opencode-ai/sdk/v2/client"
 import { createSimpleContext } from "@opencode-ai/ui/context"
 import { createGlobalEmitter } from "@solid-primitives/event-bus"
-import { makeEventListener } from "@solid-primitives/event-listener"
+import { batch, onCleanup } from "solid-js"
-import { batch, onCleanup, onMount } from "solid-js"
 import z from "zod"
 import { createSdkForServer } from "@/utils/server"
 import { useLanguage } from "./language"
@@ -106,8 +105,6 @@ export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleCo
     const aborted = (error: unknown) => abortError.safeParse(error).success
 
     let attempt: AbortController | undefined
-    let run: Promise<void> | undefined
-    let started = false
     const HEARTBEAT_TIMEOUT_MS = 15_000
     let lastEventAt = Date.now()
     let heartbeat: ReturnType<typeof setTimeout> | undefined
@@ -124,100 +121,89 @@ export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleCo
       heartbeat = undefined
     }
 
-    const start = () => {
+    void (async () => {
-      if (started) return run
+      while (!abort.signal.aborted) {
-      started = true
+        attempt = new AbortController()
-      run = (async () => {
+        lastEventAt = Date.now()
-        while (!abort.signal.aborted && started) {
+        const onAbort = () => {
-          attempt = new AbortController()
+          attempt?.abort()
-          lastEventAt = Date.now()
+        }
-          const onAbort = () => {
+        abort.signal.addEventListener("abort", onAbort)
-            attempt?.abort()
+        try {
-          }
+          const events = await eventSdk.global.event({
-          abort.signal.addEventListener("abort", onAbort)
+            signal: attempt.signal,
-          try {
+            onSseError: (error) => {
-            const events = await eventSdk.global.event({
+              if (aborted(error)) return
-              signal: attempt.signal,
+              if (streamErrorLogged) return
-              onSseError: (error) => {
-                if (aborted(error)) return
-                if (streamErrorLogged) return
-                streamErrorLogged = true
-                console.error("[global-sdk] event stream error", {
-                  url: currentServer.http.url,
-                  fetch: eventFetch ? "platform" : "webview",
-                  error,
-                })
-              },
-            })
-            let yielded = Date.now()
-            resetHeartbeat()
-            for await (const event of events.stream) {
-              resetHeartbeat()
-              streamErrorLogged = false
-              const directory = event.directory ?? "global"
-              const payload = event.payload
-              const k = key(directory, payload)
-              if (k) {
-                const i = coalesced.get(k)
-                if (i !== undefined) {
-                  queue[i] = { directory, payload }
-                  if (payload.type === "message.part.updated") {
-                    const part = payload.properties.part
-                    staleDeltas.add(deltaKey(directory, part.messageID, part.id))
-                  }
-                  continue
-                }
-                coalesced.set(k, queue.length)
-              }
-              queue.push({ directory, payload })
-              schedule()
-
-              if (Date.now() - yielded < STREAM_YIELD_MS) continue
-              yielded = Date.now()
-              await wait(0)
-            }
-          } catch (error) {
-            if (!aborted(error) && !streamErrorLogged) {
               streamErrorLogged = true
-              console.error("[global-sdk] event stream failed", {
+              console.error("[global-sdk] event stream error", {
                 url: currentServer.http.url,
                 fetch: eventFetch ? "platform" : "webview",
                 error,
               })
+            },
+          })
+          let yielded = Date.now()
+          resetHeartbeat()
+          for await (const event of events.stream) {
+            resetHeartbeat()
+            streamErrorLogged = false
+            const directory = event.directory ?? "global"
+            const payload = event.payload
+            const k = key(directory, payload)
+            if (k) {
+              const i = coalesced.get(k)
+              if (i !== undefined) {
+                queue[i] = { directory, payload }
+                if (payload.type === "message.part.updated") {
+                  const part = payload.properties.part
+                  staleDeltas.add(deltaKey(directory, part.messageID, part.id))
+                }
+                continue
+              }
+              coalesced.set(k, queue.length)
             }
-          } finally {
+            queue.push({ directory, payload })
-            abort.signal.removeEventListener("abort", onAbort)
+            schedule()
-            attempt = undefined
+
-            clearHeartbeat()
+            if (Date.now() - yielded < STREAM_YIELD_MS) continue
+            yielded = Date.now()
+            await wait(0)
           }
-
+        } catch (error) {
-          if (abort.signal.aborted || !started) return
+          if (!aborted(error) && !streamErrorLogged) {
-          await wait(RECONNECT_DELAY_MS)
+            streamErrorLogged = true
+            console.error("[global-sdk] event stream failed", {
+              url: currentServer.http.url,
+              fetch: eventFetch ? "platform" : "webview",
+              error,
+            })
+          }
+        } finally {
+          abort.signal.removeEventListener("abort", onAbort)
+          attempt = undefined
+          clearHeartbeat()
         }
-      })().finally(() => {
-        run = undefined
-        flush()
-      })
-      return run
-    }
 
-    const stop = () => {
+        if (abort.signal.aborted) return
-      started = false
+        await wait(RECONNECT_DELAY_MS)
+      }
+    })().finally(flush)
+
+    const onVisibility = () => {
+      if (typeof document === "undefined") return
+      if (document.visibilityState !== "visible") return
+      if (Date.now() - lastEventAt < HEARTBEAT_TIMEOUT_MS) return
       attempt?.abort()
-      clearHeartbeat()
     }
-
+    if (typeof document !== "undefined") {
-    onMount(() => {
+      document.addEventListener("visibilitychange", onVisibility)
-      makeEventListener(document, "visibilitychange", () => {
+    }
-        if (document.visibilityState !== "visible") return
-        if (!started) return
-        if (Date.now() - lastEventAt < HEARTBEAT_TIMEOUT_MS) return
-        attempt?.abort()
-      })
-    })
 
     onCleanup(() => {
-      stop()
+      if (typeof document !== "undefined") {
+        document.removeEventListener("visibilitychange", onVisibility)
+      }
       abort.abort()
       flush()
     })
@@ -231,11 +217,7 @@ export const { use: useGlobalSDK, provider: GlobalSDKProvider } = createSimpleCo
     return {
       url: currentServer.http.url,
       client: sdk,
-      event: {
+      event: emitter,
-        on: emitter.on.bind(emitter),
-        listen: emitter.listen.bind(emitter),
-        start,
-      },
       createClient(opts: Omit<Parameters<typeof createSdkForServer>[0], "server" | "fetch">) {
         const s = server.current
         if (!s) throw new Error(language.t("error.globalSDK.serverNotAvailable"))

packages/app/src/context/global-sync.tsx

@@ -9,13 +9,23 @@ import type {
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@opencode-ai/ui/toast"
 import { getFilename } from "@opencode-ai/util/path"
-import { createContext, getOwner, onCleanup, onMount, type ParentProps, untrack, useContext } from "solid-js"
+import {
+  createContext,
+  getOwner,
+  Match,
+  onCleanup,
+  onMount,
+  type ParentProps,
+  Switch,
+  untrack,
+  useContext,
+} from "solid-js"
 import { createStore, produce, reconcile } from "solid-js/store"
 import { useLanguage } from "@/context/language"
 import { Persist, persisted } from "@/utils/persist"
 import type { InitError } from "../pages/error"
 import { useGlobalSDK } from "./global-sdk"
-import { bootstrapDirectory, bootstrapGlobal, clearProviderRev } from "./global-sync/bootstrap"
+import { bootstrapDirectory, bootstrapGlobal } from "./global-sync/bootstrap"
 import { createChildStoreManager } from "./global-sync/child-store"
 import { applyDirectoryEvent, applyGlobalEvent, cleanupDroppedSessionCaches } from "./global-sync/event-reducer"
 import { createRefreshQueue } from "./global-sync/queue"
@@ -70,18 +80,10 @@ function createGlobalSync() {
 
   let active = true
   let projectWritten = false
-  let bootedAt = 0
-  let bootingRoot = false
-  let eventFrame: number | undefined
-  let eventTimer: ReturnType<typeof setTimeout> | undefined
 
   onCleanup(() => {
     active = false
   })
-  onCleanup(() => {
-    if (eventFrame !== undefined) cancelAnimationFrame(eventFrame)
-    if (eventTimer !== undefined) clearTimeout(eventTimer)
-  })
 
   const cacheProjects = () => {
     setProjectCache(
@@ -160,7 +162,6 @@ function createGlobalSync() {
       queue.clear(directory)
       sessionMeta.delete(directory)
       sdkCache.delete(directory)
-      clearProviderRev(directory)
       clearSessionPrefetchDirectory(directory)
     },
     translate: language.t,
@@ -257,12 +258,6 @@ function createGlobalSync() {
       const sdk = sdkFor(directory)
       await bootstrapDirectory({
         directory,
-        global: {
-          config: globalStore.config,
-          path: globalStore.path,
-          project: globalStore.project,
-          provider: globalStore.provider,
-        },
         sdk,
         store: child[0],
         setStore: child[1],
@@ -283,20 +278,15 @@ function createGlobalSync() {
   const unsub = globalSDK.event.listen((e) => {
     const directory = e.name
     const event = e.details
-    const recent = bootingRoot || Date.now() - bootedAt < 1500
 
     if (directory === "global") {
       applyGlobalEvent({
         event,
         project: globalStore.project,
-        refresh: () => {
+        refresh: queue.refresh,
-          if (recent) return
-          queue.refresh()
-        },
         setGlobalProject: setProjects,
       })
       if (event.type === "server.connected" || event.type === "global.disposed") {
-        if (recent) return
         for (const directory of Object.keys(children.children)) {
           queue.push(directory)
         }
@@ -319,10 +309,7 @@ function createGlobalSync() {
       loadLsp: () => {
         sdkFor(directory)
           .lsp.status()
-          .then((x) => {
+          .then((x) => setStore("lsp", x.data ?? []))
-            setStore("lsp", x.data ?? [])
-            setStore("lsp_ready", true)
-          })
       },
     })
   })
@@ -338,36 +325,20 @@ function createGlobalSync() {
   })
 
   async function bootstrap() {
-    bootingRoot = true
+    await bootstrapGlobal({
-    try {
+      globalSDK: globalSDK.client,
-      await bootstrapGlobal({
+      connectErrorTitle: language.t("dialog.server.add.error"),
-        globalSDK: globalSDK.client,
+      connectErrorDescription: language.t("error.globalSync.connectFailed", {
-        requestFailedTitle: language.t("common.requestFailed"),
+        url: globalSDK.url,
-        translate: language.t,
+      }),
-        formatMoreCount: (count) => language.t("common.moreCountSuffix", { count }),
+      requestFailedTitle: language.t("common.requestFailed"),
-        setGlobalStore: setBootStore,
+      translate: language.t,
-      })
+      formatMoreCount: (count) => language.t("common.moreCountSuffix", { count }),
-      bootedAt = Date.now()
+      setGlobalStore: setBootStore,
-    } finally {
+    })
-      bootingRoot = false
-    }
   }
 
   onMount(() => {
-    if (typeof requestAnimationFrame === "function") {
-      eventFrame = requestAnimationFrame(() => {
-        eventFrame = undefined
-        eventTimer = setTimeout(() => {
-          eventTimer = undefined
-          globalSDK.event.start()
-        }, 0)
-      })
-    } else {
-      eventTimer = setTimeout(() => {
-        eventTimer = undefined
-        globalSDK.event.start()
-      }, 0)
-    }
     void bootstrap()
   })
 
@@ -421,7 +392,13 @@ const GlobalSyncContext = createContext<ReturnType<typeof createGlobalSync>>()
 
 export function GlobalSyncProvider(props: ParentProps) {
   const value = createGlobalSync()
-  return <GlobalSyncContext.Provider value={value}>{props.children}</GlobalSyncContext.Provider>
+  return (
+    <Switch>
+      <Match when={value.ready}>
+        <GlobalSyncContext.Provider value={value}>{props.children}</GlobalSyncContext.Provider>
+      </Match>
+    </Switch>
+  )
 }
 
 export function useGlobalSync() {

packages/app/src/context/global-sync/bootstrap.ts

@@ -7,7 +7,6 @@ import type {
   ProviderAuthResponse,
   ProviderListResponse,
   QuestionRequest,
-  Session,
   Todo,
 } from "@opencode-ai/sdk/v2/client"
 import { showToast } from "@opencode-ai/ui/toast"
@@ -16,7 +15,7 @@ import { retry } from "@opencode-ai/util/retry"
 import { batch } from "solid-js"
 import { reconcile, type SetStoreFunction, type Store } from "solid-js/store"
 import type { State, VcsCache } from "./types"
-import { cmp, normalizeAgentList, normalizeProviderList } from "./utils"
+import { cmp, normalizeProviderList } from "./utils"
 import { formatServerError } from "@/utils/server-errors"
 
 type GlobalStore = {
@@ -32,110 +31,73 @@ type GlobalStore = {
   reload: undefined | "pending" | "complete"
 }
 
-function waitForPaint() {
-  return new Promise<void>((resolve) => {
-    let done = false
-    const finish = () => {
-      if (done) return
-      done = true
-      resolve()
-    }
-    const timer = setTimeout(finish, 50)
-    if (typeof requestAnimationFrame !== "function") return
-    requestAnimationFrame(() => {
-      setTimeout(() => {
-        clearTimeout(timer)
-        finish()
-      }, 0)
-    })
-  })
-}
-
-function errors(list: PromiseSettledResult<unknown>[]) {
-  return list.filter((item): item is PromiseRejectedResult => item.status === "rejected").map((item) => item.reason)
-}
-
-const providerRev = new Map<string, number>()
-
-export function clearProviderRev(directory: string) {
-  providerRev.delete(directory)
-}
-
-function runAll(list: Array<() => Promise<unknown>>) {
-  return Promise.allSettled(list.map((item) => item()))
-}
-
-function showErrors(input: {
-  errors: unknown[]
-  title: string
-  translate: (key: string, vars?: Record<string, string | number>) => string
-  formatMoreCount: (count: number) => string
-}) {
-  if (input.errors.length === 0) return
-  const message = formatServerError(input.errors[0], input.translate)
-  const more = input.errors.length > 1 ? input.formatMoreCount(input.errors.length - 1) : ""
-  showToast({
-    variant: "error",
-    title: input.title,
-    description: message + more,
-  })
-}
-
 export async function bootstrapGlobal(input: {
   globalSDK: OpencodeClient
+  connectErrorTitle: string
+  connectErrorDescription: string
   requestFailedTitle: string
   translate: (key: string, vars?: Record<string, string | number>) => string
   formatMoreCount: (count: number) => string
   setGlobalStore: SetStoreFunction<GlobalStore>
 }) {
-  const fast = [
+  const health = await input.globalSDK.global
-    () =>
+    .health()
-      retry(() =>
+    .then((x) => x.data)
-        input.globalSDK.global.config.get().then((x) => {
+    .catch(() => undefined)
-          input.setGlobalStore("config", x.data!)
+  if (!health?.healthy) {
-        }),
+    showToast({
-      ),
+      variant: "error",
-    () =>
+      title: input.connectErrorTitle,
-      retry(() =>
+      description: input.connectErrorDescription,
-        input.globalSDK.provider.list().then((x) => {
+    })
-          input.setGlobalStore("provider", normalizeProviderList(x.data!))
+    input.setGlobalStore("ready", true)
-        }),
+    return
-      ),
+  }
+
+  const tasks = [
+    retry(() =>
+      input.globalSDK.path.get().then((x) => {
+        input.setGlobalStore("path", x.data!)
+      }),
+    ),
+    retry(() =>
+      input.globalSDK.global.config.get().then((x) => {
+        input.setGlobalStore("config", x.data!)
+      }),
+    ),
+    retry(() =>
+      input.globalSDK.project.list().then((x) => {
+        const projects = (x.data ?? [])
+          .filter((p) => !!p?.id)
+          .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
+          .slice()
+          .sort((a, b) => cmp(a.id, b.id))
+        input.setGlobalStore("project", projects)
+      }),
+    ),
+    retry(() =>
+      input.globalSDK.provider.list().then((x) => {
+        input.setGlobalStore("provider", normalizeProviderList(x.data!))
+      }),
+    ),
+    retry(() =>
+      input.globalSDK.provider.auth().then((x) => {
+        input.setGlobalStore("provider_auth", x.data ?? {})
+      }),
+    ),
   ]
 
-  const slow = [
+  const results = await Promise.allSettled(tasks)
-    () =>
+  const errors = results.filter((r): r is PromiseRejectedResult => r.status === "rejected").map((r) => r.reason)
-      retry(() =>
+  if (errors.length) {
-        input.globalSDK.path.get().then((x) => {
+    const message = formatServerError(errors[0], input.translate)
-          input.setGlobalStore("path", x.data!)
+    const more = errors.length > 1 ? input.formatMoreCount(errors.length - 1) : ""
-        }),
+    showToast({
-      ),
+      variant: "error",
-    () =>
+      title: input.requestFailedTitle,
-      retry(() =>
+      description: message + more,
-        input.globalSDK.project.list().then((x) => {
+    })
-          const projects = (x.data ?? [])
+  }
-            .filter((p) => !!p?.id)
-            .filter((p) => !!p.worktree && !p.worktree.includes("opencode-test"))
-            .slice()
-            .sort((a, b) => cmp(a.id, b.id))
-          input.setGlobalStore("project", projects)
-        }),
-      ),
-  ]
-
-  showErrors({
-    errors: errors(await runAll(fast)),
-    title: input.requestFailedTitle,
-    translate: input.translate,
-    formatMoreCount: input.formatMoreCount,
-  })
-  await waitForPaint()
-  showErrors({
-    errors: errors(await runAll(slow)),
-    title: input.requestFailedTitle,
-    translate: input.translate,
-    formatMoreCount: input.formatMoreCount,
-  })
   input.setGlobalStore("ready", true)
 }
 
@@ -149,44 +111,6 @@ function groupBySession<T extends { id: string; sessionID: string }>(input: T[])
   }, {})
 }
 
-function projectID(directory: string, projects: Project[]) {
-  return projects.find((project) => project.worktree === directory || project.sandboxes?.includes(directory))?.id
-}
-
-function mergeSession(setStore: SetStoreFunction<State>, session: Session) {
-  setStore("session", (list) => {
-    const next = list.slice()
-    const idx = next.findIndex((item) => item.id >= session.id)
-    if (idx === -1) return [...next, session]
-    if (next[idx]?.id === session.id) {
-      next[idx] = session
-      return next
-    }
-    next.splice(idx, 0, session)
-    return next
-  })
-}
-
-function warmSessions(input: {
-  ids: string[]
-  store: Store<State>
-  setStore: SetStoreFunction<State>
-  sdk: OpencodeClient
-}) {
-  const known = new Set(input.store.session.map((item) => item.id))
-  const ids = [...new Set(input.ids)].filter((id) => !!id && !known.has(id))
-  if (ids.length === 0) return Promise.resolve()
-  return Promise.all(
-    ids.map((sessionID) =>
-      retry(() => input.sdk.session.get({ sessionID })).then((x) => {
-        const session = x.data
-        if (!session?.id) return
-        mergeSession(input.setStore, session)
-      }),
-    ),
-  ).then(() => undefined)
-}
-
 export async function bootstrapDirectory(input: {
   directory: string
   sdk: OpencodeClient
@@ -195,166 +119,88 @@ export async function bootstrapDirectory(input: {
   vcsCache: VcsCache
   loadSessions: (directory: string) => Promise<void> | void
   translate: (key: string, vars?: Record<string, string | number>) => string
-  global: {
-    config: Config
-    path: Path
-    project: Project[]
-    provider: ProviderListResponse
-  }
 }) {
-  const loading = input.store.status !== "complete"
+  if (input.store.status !== "complete") input.setStore("status", "loading")
-  const seededProject = projectID(input.directory, input.global.project)
-  const seededPath = input.global.path.directory === input.directory ? input.global.path : undefined
-  if (seededProject) input.setStore("project", seededProject)
-  if (seededPath) input.setStore("path", seededPath)
-  if (input.store.provider.all.length === 0 && input.global.provider.all.length > 0) {
-    input.setStore("provider", input.global.provider)
-  }
-  if (Object.keys(input.store.config).length === 0 && Object.keys(input.global.config).length > 0) {
-    input.setStore("config", input.global.config)
-  }
-  if (loading || input.store.provider.all.length === 0) {
-    input.setStore("provider_ready", false)
-  }
-  input.setStore("mcp_ready", false)
-  input.setStore("mcp", {})
-  input.setStore("lsp_ready", false)
-  input.setStore("lsp", [])
-  if (loading) input.setStore("status", "partial")
 
-  const fast = [
+  const blockingRequests = {
-    () => retry(() => input.sdk.app.agents().then((x) => input.setStore("agent", normalizeAgentList(x.data)))),
+    project: () => input.sdk.project.current().then((x) => input.setStore("project", x.data!.id)),
-    () => retry(() => input.sdk.config.get().then((x) => input.setStore("config", x.data!))),
+    provider: () =>
-    () => retry(() => input.sdk.session.status().then((x) => input.setStore("session_status", x.data!))),
+      input.sdk.provider.list().then((x) => {
-  ]
+        input.setStore("provider", normalizeProviderList(x.data!))
+      }),
+    agent: () => input.sdk.app.agents().then((x) => input.setStore("agent", x.data ?? [])),
+    config: () => input.sdk.config.get().then((x) => input.setStore("config", x.data!)),
+  }
 
-  const slow = [
+  try {
-    () =>
+    await Promise.all(Object.values(blockingRequests).map((p) => retry(p)))
-      seededProject
+  } catch (err) {
-        ? Promise.resolve()
+    console.error("Failed to bootstrap instance", err)
-        : retry(() => input.sdk.project.current()).then((x) => input.setStore("project", x.data!.id)),
-    () =>
-      seededPath
-        ? Promise.resolve()
-        : retry(() =>
-            input.sdk.path.get().then((x) => {
-              input.setStore("path", x.data!)
-              const next = projectID(x.data?.directory ?? input.directory, input.global.project)
-              if (next) input.setStore("project", next)
-            }),
-          ),
-    () =>
-      retry(() =>
-        input.sdk.vcs.get().then((x) => {
-          const next = x.data ?? input.store.vcs
-          input.setStore("vcs", next)
-          if (next) input.vcsCache.setStore("value", next)
-        }),
-      ),
-    () => retry(() => input.sdk.command.list().then((x) => input.setStore("command", x.data ?? []))),
-    () =>
-      retry(() =>
-        input.sdk.permission.list().then((x) => {
-          const ids = (x.data ?? []).map((perm) => perm?.sessionID).filter((id): id is string => !!id)
-          const grouped = groupBySession(
-            (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm.sessionID),
-          )
-          return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
-            batch(() => {
-              for (const sessionID of Object.keys(input.store.permission)) {
-                if (grouped[sessionID]) continue
-                input.setStore("permission", sessionID, [])
-              }
-              for (const [sessionID, permissions] of Object.entries(grouped)) {
-                input.setStore(
-                  "permission",
-                  sessionID,
-                  reconcile(
-                    permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
-                    { key: "id" },
-                  ),
-                )
-              }
-            }),
-          )
-        }),
-      ),
-    () =>
-      retry(() =>
-        input.sdk.question.list().then((x) => {
-          const ids = (x.data ?? []).map((question) => question?.sessionID).filter((id): id is string => !!id)
-          const grouped = groupBySession((x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID))
-          return warmSessions({ ids, store: input.store, setStore: input.setStore, sdk: input.sdk }).then(() =>
-            batch(() => {
-              for (const sessionID of Object.keys(input.store.question)) {
-                if (grouped[sessionID]) continue
-                input.setStore("question", sessionID, [])
-              }
-              for (const [sessionID, questions] of Object.entries(grouped)) {
-                input.setStore(
-                  "question",
-                  sessionID,
-                  reconcile(
-                    questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
-                    { key: "id" },
-                  ),
-                )
-              }
-            }),
-          )
-        }),
-      ),
-    () => Promise.resolve(input.loadSessions(input.directory)),
-    () =>
-      retry(() =>
-        input.sdk.mcp.status().then((x) => {
-          input.setStore("mcp", x.data!)
-          input.setStore("mcp_ready", true)
-        }),
-      ),
-  ]
-
-  const errs = errors(await runAll(fast))
-  if (errs.length > 0) {
-    console.error("Failed to bootstrap instance", errs[0])
     const project = getFilename(input.directory)
     showToast({
       variant: "error",
       title: input.translate("toast.project.reloadFailed.title", { project }),
-      description: formatServerError(errs[0], input.translate),
+      description: formatServerError(err, input.translate),
     })
+    input.setStore("status", "partial")
+    return
   }
 
-  await waitForPaint()
+  if (input.store.status !== "complete") input.setStore("status", "partial")
-  const slowErrs = errors(await runAll(slow))
-  if (slowErrs.length > 0) {
-    console.error("Failed to finish bootstrap instance", slowErrs[0])
-    const project = getFilename(input.directory)
-    showToast({
-      variant: "error",
-      title: input.translate("toast.project.reloadFailed.title", { project }),
-      description: formatServerError(slowErrs[0], input.translate),
-    })
-  }
 
-  if (loading && errs.length === 0 && slowErrs.length === 0) input.setStore("status", "complete")
+  Promise.all([
-
+    input.sdk.path.get().then((x) => input.setStore("path", x.data!)),
-  const rev = (providerRev.get(input.directory) ?? 0) + 1
+    input.sdk.command.list().then((x) => input.setStore("command", x.data ?? [])),
-  providerRev.set(input.directory, rev)
+    input.sdk.session.status().then((x) => input.setStore("session_status", x.data!)),
-  void retry(() => input.sdk.provider.list())
+    input.loadSessions(input.directory),
-    .then((x) => {
+    input.sdk.mcp.status().then((x) => input.setStore("mcp", x.data!)),
-      if (providerRev.get(input.directory) !== rev) return
+    input.sdk.lsp.status().then((x) => input.setStore("lsp", x.data!)),
-      input.setStore("provider", normalizeProviderList(x.data!))
+    input.sdk.vcs.get().then((x) => {
-      input.setStore("provider_ready", true)
+      const next = x.data ?? input.store.vcs
-    })
+      input.setStore("vcs", next)
-    .catch((err) => {
+      if (next?.branch) input.vcsCache.setStore("value", next)
-      if (providerRev.get(input.directory) !== rev) return
+    }),
-      console.error("Failed to refresh provider list", err)
+    input.sdk.permission.list().then((x) => {
-      const project = getFilename(input.directory)
+      const grouped = groupBySession(
-      showToast({
+        (x.data ?? []).filter((perm): perm is PermissionRequest => !!perm?.id && !!perm.sessionID),
-        variant: "error",
+      )
-        title: input.translate("toast.project.reloadFailed.title", { project }),
+      batch(() => {
-        description: formatServerError(err, input.translate),
+        for (const sessionID of Object.keys(input.store.permission)) {
+          if (grouped[sessionID]) continue
+          input.setStore("permission", sessionID, [])
+        }
+        for (const [sessionID, permissions] of Object.entries(grouped)) {
+          input.setStore(
+            "permission",
+            sessionID,
+            reconcile(
+              permissions.filter((p) => !!p?.id).sort((a, b) => cmp(a.id, b.id)),
+              { key: "id" },
+            ),
+          )
+        }
       })
-    })
+    }),
+    input.sdk.question.list().then((x) => {
+      const grouped = groupBySession((x.data ?? []).filter((q): q is QuestionRequest => !!q?.id && !!q.sessionID))
+      batch(() => {
+        for (const sessionID of Object.keys(input.store.question)) {
+          if (grouped[sessionID]) continue
+          input.setStore("question", sessionID, [])
+        }
+        for (const [sessionID, questions] of Object.entries(grouped)) {
+          input.setStore(
+            "question",
+            sessionID,
+            reconcile(
+              questions.filter((q) => !!q?.id).sort((a, b) => cmp(a.id, b.id)),
+              { key: "id" },
+            ),
+          )
+        }
+      })
+    }),
+  ]).then(() => {
+    input.setStore("status", "complete")
+  })
 }

packages/app/src/context/global-sync/child-store.ts

@@ -160,7 +160,6 @@ export function createChildStoreManager(input: {
             project: "",
             projectMeta: initialMeta,
             icon: initialIcon,
-            provider_ready: false,
             provider: { all: [], connected: [], default: {} },
             config: {},
             path: { state: "", config: "", worktree: "", directory: "", home: "" },
@@ -174,9 +173,7 @@ export function createChildStoreManager(input: {
             todo: {},
             permission: {},
             question: {},
-            mcp_ready: false,
             mcp: {},
-            lsp_ready: false,
             lsp: [],
             vcs: vcsStore.value,
             limit: 5,

packages/app/src/context/global-sync/event-reducer.test.ts

@@ -494,10 +494,8 @@ describe("applyDirectoryEvent", () => {
   })
 
   test("updates vcs branch in store and cache", () => {
-    const [store, setStore] = createStore(baseState({ vcs: { branch: "main", default_branch: "main" } }))
+    const [store, setStore] = createStore(baseState())
-    const [cacheStore, setCacheStore] = createStore({
+    const [cacheStore, setCacheStore] = createStore({ value: undefined as State["vcs"] })
-      value: { branch: "main", default_branch: "main" } as State["vcs"],
-    })
 
     applyDirectoryEvent({
       event: { type: "vcs.branch.updated", properties: { branch: "feature/test" } },
@@ -513,8 +511,8 @@ describe("applyDirectoryEvent", () => {
       },
     })
 
-    expect(store.vcs).toEqual({ branch: "feature/test", default_branch: "main" })
+    expect(store.vcs).toEqual({ branch: "feature/test" })
-    expect(cacheStore.value).toEqual({ branch: "feature/test", default_branch: "main" })
+    expect(cacheStore.value).toEqual({ branch: "feature/test" })
   })
 
   test("routes disposal and lsp events to side-effect handlers", () => {