bugfix: fix crash bug in token cache logic

This change fixes a problem in the token cache logic to avoid panics caused by empty token arrays by ensuring at least one token remains on full cache hits in the relevant function. The happens if there is an exact match in the cache on subsequent generations.
2026-09-08 12:13:43 -04:00 · 2026-02-26 18:35:44 -08:00
622 changed files with 19081 additions and 105123 deletions
@@ -27,7 +27,7 @@ jobs:
          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT

  darwin-build:
-    runs-on: macos-26-xlarge
+    runs-on: macos-14-xlarge
    environment: release
    needs: setup-environment
    env:
@@ -117,45 +117,16 @@ jobs:
            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
            flags: ''
            runner_dir: 'vulkan'
-          - os: windows
-            arch: amd64
-            preset: 'MLX CUDA 13'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
-            flags: ''
    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
    environment: release
    env:
      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
    steps:
-      # Increase pagefile to handle momentary spikes in RAM from NVCC compiles
-      - if: startsWith(matrix.preset, 'MLX ')
-        name: Increase pagefile to 200 GB
-        uses: al-cheb/configure-pagefile-action@v1.5
-        with:
-          minimum-size: 16GB
-          maximum-size: 200GB
-          disk-root: "D:"
      - name: Install system dependencies
        run: |
          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan') || startsWith(matrix.preset, 'MLX ')
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'ROCm ') || startsWith(matrix.preset, 'Vulkan')
        id: cache-install
        uses: actions/cache/restore@v4
        with:
@@ -163,9 +134,8 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: startsWith(matrix.preset, 'CUDA ') || startsWith(matrix.preset, 'MLX ')
+          key: ${{ matrix.install }}
+      - if: startsWith(matrix.preset, 'CUDA ')
        name: Install CUDA ${{ matrix.cuda-version }}
        run: |
          $ErrorActionPreference = "Stop"
@@ -209,23 +179,6 @@ jobs:
        run: |
          echo "CC=clang.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
          echo "CXX=clang++.exe" | Out-File -FilePath $env:GITHUB_ENV -Append
-      - if: startsWith(matrix.preset, 'MLX ')
-        name: Install cuDNN for MLX
-        run: |
-          $ErrorActionPreference = "Stop"
-          $cudnnRoot = "C:\Program Files\NVIDIA\CUDNN"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.cudnn-install }}" -OutFile "cudnn.zip"
-            Expand-Archive -Path cudnn.zip -DestinationPath cudnn-extracted
-            $cudnnDir = (Get-ChildItem -Path cudnn-extracted -Directory)[0].FullName
-            New-Item -ItemType Directory -Force -Path $cudnnRoot
-            Copy-Item -Path "$cudnnDir\*" -Destination "$cudnnRoot\" -Recurse
-          }
-
-          echo "CUDNN_ROOT_DIR=$cudnnRoot" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_INCLUDE_PATH=$cudnnRoot\include" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_LIBRARY_PATH=$cudnnRoot\lib\x64" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "$cudnnRoot\bin\x64" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
      - if: ${{ !cancelled() && steps.cache-install.outputs.cache-hit != 'true' }}
        uses: actions/cache/save@v4
        with:
@@ -233,8 +186,7 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          key: ${{ matrix.install }}
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
        with:
@@ -245,9 +197,8 @@ jobs:
          Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }} --install-prefix "$((pwd).Path)\dist\${{ matrix.os }}-${{ matrix.arch }}"
-          cmake --build --preset "${{ matrix.preset }}" -- -l $([Environment]::ProcessorCount)
-          cmake --install build --component "${{ startsWith(matrix.preset, 'MLX ') && 'MLX' || startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || startsWith(matrix.preset, 'Vulkan') && 'Vulkan' || 'CPU' }}" --strip
-          if ('${{ matrix.preset }}'.StartsWith('MLX ')) { cmake --install build --component MLX_VENDOR }
+          cmake --build --parallel ([Environment]::ProcessorCount) --preset "${{ matrix.preset }}"
+          cmake --install build --component "${{ startsWith(matrix.preset, 'CUDA ') && 'CUDA' || startsWith(matrix.preset, 'ROCm ') && 'HIP' || startsWith(matrix.preset, 'Vulkan') && 'Vulkan' || 'CPU' }}" --strip
          Remove-Item -Path dist\lib\ollama\rocm\rocblas\library\*gfx906* -ErrorAction SilentlyContinue
        env:
          CMAKE_GENERATOR: Ninja
@@ -389,36 +340,20 @@ jobs:
            dist/*.ps1
            dist/OllamaSetup.exe

-  # Pre-build each Dockerfile stage on its own runner in parallel and push the
-  # resulting layers to a per-stage registry cache.  The downstream
-  # docker-build-push job then assembles cache-hit-only.
-  linux-depends:
+  linux-build:
    strategy:
      matrix:
        include:
-          - arch: amd64
-            target: cpu
-          - arch: amd64
-            target: cuda-12
-          - arch: amd64
-            target: cuda-13
-          - arch: amd64
-            target: mlx
-          - arch: amd64
-            target: rocm-7
-          - arch: amd64
-            target: vulkan
-          - arch: arm64
-            target: cpu
-          - arch: arm64
-            target: cuda-12
-          - arch: arm64
-            target: cuda-13
-          - arch: arm64
-            target: jetpack-5
-          - arch: arm64
-            target: jetpack-6
-    runs-on: ${{ matrix.arch == 'arm64' && 'linux-arm64' || 'linux' }}
+          - os: linux
+            arch: amd64
+            target: archive
+          - os: linux
+            arch: amd64
+            target: rocm
+          - os: linux
+            arch: arm64
+            target: archive
+    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
    environment: release
    needs: setup-environment
    env:
@@ -426,53 +361,52 @@ jobs:
    steps:
      - uses: actions/checkout@v4
      - uses: docker/setup-buildx-action@v3
-      - uses: docker/login-action@v3
-        with:
-          username: ${{ vars.DOCKER_USER }}
-          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
-      # Increase swap to handle momentary spikes in RAM from NVCC compiles
-      - if: matrix.target == 'mlx'
-        name: Increase Linux swap to 200 GB
-        shell: bash
-        run: |
-          set -e
-          SWAP_PATH=/swapfile-mlx
-          SWAP_SIZE_GB=200
-          if [ -f "$SWAP_PATH" ]; then
-              sudo swapoff "$SWAP_PATH" 2>/dev/null || true
-              sudo rm -f "$SWAP_PATH"
-          fi
-          if ! sudo fallocate -l ${SWAP_SIZE_GB}G "$SWAP_PATH" 2>/dev/null; then
-              echo "fallocate unsupported, falling back to dd"
-              sudo dd if=/dev/zero of="$SWAP_PATH" bs=1M count=$((SWAP_SIZE_GB * 1024))
-          fi
-          sudo chmod 600 "$SWAP_PATH"
-          sudo mkswap "$SWAP_PATH"
-          sudo swapon "$SWAP_PATH"
-          swapon --show
-          free -h
      - uses: docker/build-push-action@v6
        with:
          context: .
-          platforms: linux/${{ matrix.arch }}
+          platforms: ${{ matrix.os }}/${{ matrix.arch }}
          target: ${{ matrix.target }}
-          provenance: false
-          sbom: false
          build-args: |
+            GOFLAGS=${{ env.GOFLAGS }}
            CGO_CFLAGS=${{ env.CGO_CFLAGS }}
            CGO_CXXFLAGS=${{ env.CGO_CXXFLAGS }}
-            GOFLAGS=${{ env.GOFLAGS }}
-            APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-            OLLAMA_MLX_BUILD_JOBS=16
-            OLLAMA_MLX_NVCC_THREADS=6
-          cache-from: |
-            type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }}
-            type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-          cache-to: type=registry,ref=ollama/release:cache-${{ matrix.arch }}-${{ matrix.target }},mode=max
+          outputs: type=local,dest=dist/${{ matrix.os }}-${{ matrix.arch }}
+          cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
+          cache-to: type=inline
+      - name: Deduplicate CUDA libraries
+        run: |
+          ./scripts/deduplicate_cuda_libs.sh dist/${{ matrix.os }}-${{ matrix.arch }}
+      - run: |
+          for COMPONENT in bin/* lib/ollama/*; do
+            case "$COMPONENT" in
+              bin/ollama*)               echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/*.so*)          echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
+              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
+              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
+              lib/ollama/rocm)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
+            esac
+          done
+        working-directory: dist/${{ matrix.os }}-${{ matrix.arch }}
+      - run: |
+          echo "Manifests"
+          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in ; do
+            echo $ARCHIVE
+            cat $ARCHIVE
+          done
+      - run: |
+          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in; do
+            tar c -C dist/${{ matrix.os }}-${{ matrix.arch }} -T $ARCHIVE --owner 0 --group 0 | zstd --ultra -22 -T0 >$(basename ${ARCHIVE//.*/}.tar.zst);
+          done
+      - uses: actions/upload-artifact@v4
+        with:
+          name: bundles-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.target }}
+          path: |
+            *.tar.zst

  # Build each Docker variant (OS, arch, and flavor) separately. Using QEMU is unreliable and slower.
-  # Heavy stages were pre-built by linux-depends; this job is cache-hit-only for those layers
-  # and just assembles, runs the Go build, and pushes the final image.
  docker-build-push:
    strategy:
      matrix:
@@ -483,32 +417,12 @@ jobs:
              CGO_CFLAGS
              CGO_CXXFLAGS
              GOFLAGS
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-              type=registry,ref=ollama/release:cache-arm64-cpu
-              type=registry,ref=ollama/release:cache-arm64-cuda-12
-              type=registry,ref=ollama/release:cache-arm64-cuda-13
-              type=registry,ref=ollama/release:cache-arm64-jetpack-5
-              type=registry,ref=ollama/release:cache-arm64-jetpack-6
          - os: linux
            arch: amd64
            build-args: |
              CGO_CFLAGS
              CGO_CXXFLAGS
              GOFLAGS
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-              type=registry,ref=ollama/release:cache-amd64-cpu
-              type=registry,ref=ollama/release:cache-amd64-cuda-12
-              type=registry,ref=ollama/release:cache-amd64-cuda-13
-              type=registry,ref=ollama/release:cache-amd64-mlx
-              type=registry,ref=ollama/release:cache-amd64-vulkan
          - os: linux
            arch: amd64
            suffix: '-rocm'
@@ -517,16 +431,9 @@ jobs:
              CGO_CXXFLAGS
              GOFLAGS
              FLAVOR=rocm
-              APT_MIRROR=http://azure.archive.ubuntu.com/ubuntu
-              OLLAMA_MLX_BUILD_JOBS=16
-              OLLAMA_MLX_NVCC_THREADS=6
-            cache-from: |
-              type=registry,ref=${{ vars.DOCKER_REPO }}:latest
-              type=registry,ref=ollama/release:cache-amd64-cpu
-              type=registry,ref=ollama/release:cache-amd64-rocm-7
    runs-on: ${{ matrix.arch == 'arm64' && format('{0}-{1}', matrix.os, matrix.arch) || matrix.os }}
    environment: release
-    needs: [setup-environment, linux-depends]
+    needs: setup-environment
    env:
      GOFLAGS: ${{ needs.setup-environment.outputs.GOFLAGS }}
    steps:
@@ -541,11 +448,9 @@ jobs:
        with:
          context: .
          platforms: ${{ matrix.os }}/${{ matrix.arch }}
-          provenance: false
-          sbom: false
          build-args: ${{ matrix.build-args }}
          outputs: type=image,name=${{ vars.DOCKER_REPO }},push-by-digest=true,name-canonical=true,push=true
-          cache-from: ${{ matrix.cache-from }}
+          cache-from: type=registry,ref=${{ vars.DOCKER_REPO }}:latest
          cache-to: type=inline
      - run: |
          mkdir -p ${{ matrix.os }}-${{ matrix.arch }}
@@ -556,58 +461,6 @@ jobs:
          name: digest-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}
          path: |
            ${{ runner.temp }}/${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.suffix }}.txt
-      # Re-run buildx with --target archive against buildkit's local cache to
-      # extract the release directory layout.  All upstream stages were just
-      # built above, so this is a cache-hit-only pass that just writes files.
-      - uses: docker/build-push-action@v6
-        with:
-          context: .
-          platforms: ${{ matrix.os }}/${{ matrix.arch }}
-          target: archive
-          provenance: false
-          sbom: false
-          build-args: ${{ matrix.build-args }}
-          outputs: type=local,dest=dist/${{ matrix.os }}-${{ matrix.arch }}
-          cache-from: ${{ matrix.cache-from }}
-      - name: Deduplicate CUDA libraries
-        run: |
-          ./scripts/deduplicate_cuda_libs.sh dist/${{ matrix.os }}-${{ matrix.arch }}
-      - run: |
-          for COMPONENT in bin/* lib/ollama/*; do
-            case "$COMPONENT" in
-              bin/ollama*)               echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/*.so*)          echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/cuda_v*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/vulkan*)        echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/mlx*)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-mlx.tar.in ;;
-              lib/ollama/include*)       echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in ;;
-              lib/ollama/cuda_jetpack5)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack5.tar.in ;;
-              lib/ollama/cuda_jetpack6)  echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-jetpack6.tar.in ;;
-              lib/ollama/rocm)           echo $COMPONENT >>ollama-${{ matrix.os }}-${{ matrix.arch }}-rocm.tar.in ;;
-            esac
-          done
-        working-directory: dist/${{ matrix.os }}-${{ matrix.arch }}
-      # rocm builds cpu + rocm libs for the container image, which
-      # creates a CPU-only amd64 tarball that would collide with the full
-      # bundle when the release job merges artifacts.
-      - if: matrix.suffix == '-rocm'
-        run: rm -f dist/${{ matrix.os }}-${{ matrix.arch }}/ollama-${{ matrix.os }}-${{ matrix.arch }}.tar.in
-      - run: |
-          echo "Manifests"
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in ; do
-            echo $ARCHIVE
-            cat $ARCHIVE
-          done
-      - run: |
-          for ARCHIVE in dist/${{ matrix.os }}-${{ matrix.arch }}/*.tar.in; do
-            tar c -C dist/${{ matrix.os }}-${{ matrix.arch }} -T $ARCHIVE --owner 0 --group 0 | zstd -19 -T0 >$(basename ${ARCHIVE//.*/}.tar.zst) &
-          done
-          wait
-      - uses: actions/upload-artifact@v4
-        with:
-          name: bundles-${{ matrix.os }}-${{ matrix.arch }}${{ matrix.suffix }}
-          path: |
-            *.tar.zst

  # Merge Docker images for the same flavor into a single multi-arch manifest
  docker-merge-push:
@@ -647,7 +500,7 @@ jobs:
  release:
    runs-on: ubuntu-latest
    environment: release
-    needs: [darwin-build, windows-app, docker-build-push]
+    needs: [darwin-build, windows-app, linux-build]
    permissions:
      contents: write
    env:
@@ -690,19 +543,11 @@ jobs:
          for payload in dist/*.txt dist/*.zip dist/*.tgz dist/*.tar.zst dist/*.exe dist/*.dmg dist/*.ps1 dist/*.sh ; do
            echo "Uploading $payload"
            gh release upload ${GITHUB_REF_NAME} $payload --clobber &
-            pids+=($!)
+            pids[$!]=$!
            sleep 1
          done
          echo "Waiting for uploads to complete"
-          failed=0
-          for pid in "${pids[@]}"; do
-            if ! wait $pid; then
-              echo "::error::Upload failed (pid $pid)"
-              failed=1
-            fi
+          for pid in "${pids[*]}"; do
+            wait $pid
          done
-          if [ $failed -ne 0 ]; then
-            echo "One or more uploads failed"
-            exit 1
-          fi
          echo "done"
@@ -22,7 +22,6 @@ jobs:
    runs-on: ubuntu-latest
    outputs:
      changed: ${{ steps.changes.outputs.changed }}
-      app_changed: ${{ steps.changes.outputs.app_changed }}
      vendorsha: ${{ steps.changes.outputs.vendorsha }}
    steps:
      - uses: actions/checkout@v4
@@ -38,8 +37,7 @@ jobs:
              | xargs python3 -c "import sys; from pathlib import Path; print(any(Path(x).match(glob) for x in sys.argv[1:] for glob in '$*'.split(' ')))"
          }

-          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*' '.github/**/*') | tee -a $GITHUB_OUTPUT
-          echo app_changed=$(changed 'app/**' 'app/**/*') | tee -a $GITHUB_OUTPUT
+          echo changed=$(changed 'llama/llama.cpp/**/*' 'ml/backend/ggml/ggml/**/*') | tee -a $GITHUB_OUTPUT
          echo vendorsha=$(make -f Makefile.sync print-base) | tee -a $GITHUB_OUTPUT

  linux:
@@ -53,7 +51,7 @@ jobs:
            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
            flags: '-DCMAKE_CUDA_ARCHITECTURES=87'
          - preset: ROCm
-            container: rocm/dev-ubuntu-22.04:7.2.1
+            container: rocm/dev-ubuntu-22.04:6.1.2
            extra-packages: rocm-libs
            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_PREFIX_PATH=/opt/rocm'
          - preset: Vulkan
@@ -62,11 +60,6 @@ jobs:
              mesa-vulkan-drivers vulkan-tools
              libvulkan1 libvulkan-dev
              vulkan-sdk cmake ccache g++ make
-          - preset: 'MLX CUDA 13'
-            container: nvidia/cuda:13.0.0-devel-ubuntu22.04
-            extra-packages: libcudnn9-dev-cuda-13 libopenblas-dev liblapack-dev liblapacke-dev git curl
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=87 -DMLX_CUDA_ARCHITECTURES=80-virtual -DBLAS_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu -DLAPACK_INCLUDE_DIRS=/usr/include/x86_64-linux-gnu'
-            install-go: true
    runs-on: linux
    container: ${{ matrix.container }}
    steps:
@@ -83,29 +76,19 @@ jobs:
            $sudo apt-get update
          fi
          $sudo apt-get install -y cmake ccache ${{ matrix.extra-packages }}
-          # MLX requires CMake 3.25+, install from official releases
-          if [ "${{ matrix.preset }}" = "MLX CUDA 13" ]; then
-            curl -fsSL https://github.com/Kitware/CMake/releases/download/v3.31.2/cmake-3.31.2-linux-$(uname -m).tar.gz | $sudo tar xz -C /usr/local --strip-components 1
-          fi
          # Export VULKAN_SDK if provided by LunarG package (defensive)
          if [ -d "/usr/lib/x86_64-linux-gnu/vulkan" ] && [ "${{ matrix.preset }}" = "Vulkan" ]; then
            echo "VULKAN_SDK=/usr" >> $GITHUB_ENV
          fi
        env:
          DEBIAN_FRONTEND: noninteractive
-      - if: matrix.install-go
-        name: Install Go
-        run: |
-          GO_VERSION=$(awk '/^go / { print $2 }' go.mod)
-          curl -fsSL "https://golang.org/dl/go${GO_VERSION}.linux-$(dpkg --print-architecture).tar.gz" | tar xz -C /usr/local
-          echo "/usr/local/go/bin" >> $GITHUB_PATH
      - uses: actions/cache@v4
        with:
          path: /github/home/.cache/ccache
          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.preset }}-${{ needs.changes.outputs.vendorsha }}
      - run: |
-          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
-          cmake --build --preset "${{ matrix.preset }}" -- -l $(nproc)
+          cmake --preset ${{ matrix.preset }} ${{ matrix.flags }}
+          cmake --build --preset ${{ matrix.preset }} --parallel

  windows:
    needs: [changes]
@@ -131,31 +114,12 @@ jobs:
            flags: '-DAMDGPU_TARGETS=gfx1010 -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_C_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma" -DCMAKE_CXX_FLAGS="-parallel-jobs=4 -Wno-ignored-attributes -Wno-deprecated-pragma"'
          - preset: Vulkan
            install: https://sdk.lunarg.com/sdk/download/1.4.321.1/windows/vulkansdk-windows-X64-1.4.321.1.exe
-          - preset: 'MLX CUDA 13'
-            install: https://developer.download.nvidia.com/compute/cuda/13.0.0/local_installers/cuda_13.0.0_windows.exe
-            cudnn-install: https://developer.download.nvidia.com/compute/cudnn/redist/cudnn/windows-x86_64/cudnn-windows-x86_64-9.18.1.3_cuda13-archive.zip
-            flags: '-DCMAKE_CUDA_ARCHITECTURES=80 -DMLX_CUDA_ARCHITECTURES=80-virtual'
-            cuda-components:
-              - '"cudart"'
-              - '"nvcc"'
-              - '"cublas"'
-              - '"cublas_dev"'
-              - '"cufft"'
-              - '"cufft_dev"'
-              - '"nvrtc"'
-              - '"nvrtc_dev"'
-              - '"crt"'
-              - '"nvvm"'
-              - '"nvptxcompiler"'
-            cuda-version: '13.0'
    runs-on: windows
    steps:
      - run: |
          choco install -y --no-progress ccache ninja
-          if (Get-Command ccache -ErrorAction SilentlyContinue) {
-            ccache -o cache_dir=${{ github.workspace }}\.ccache
-          }
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan' || matrix.preset == 'MLX CUDA 13'
+          ccache -o cache_dir=${{ github.workspace }}\.ccache
+      - if: matrix.preset == 'CUDA' || matrix.preset == 'ROCm' || matrix.preset == 'Vulkan'
        id: cache-install
        uses: actions/cache/restore@v4
        with:
@@ -163,9 +127,8 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
-      - if: matrix.preset == 'CUDA' || matrix.preset == 'MLX CUDA 13'
+          key: ${{ matrix.install }}
+      - if: matrix.preset == 'CUDA'
        name: Install CUDA ${{ matrix.cuda-version }}
        run: |
          $ErrorActionPreference = "Stop"
@@ -201,27 +164,10 @@ jobs:
            Invoke-WebRequest -Uri "${{ matrix.install }}" -OutFile "install.exe"
            Start-Process -FilePath .\install.exe -ArgumentList "-c","--am","--al","in" -NoNewWindow -Wait
          }
-
+          
          $vulkanPath = (Resolve-Path "C:\VulkanSDK\*").path
          echo "$vulkanPath\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
          echo "VULKAN_SDK=$vulkanPath" >> $env:GITHUB_ENV
-      - if: matrix.preset == 'MLX CUDA 13'
-        name: Install cuDNN for MLX
-        run: |
-          $ErrorActionPreference = "Stop"
-          $cudnnRoot = "C:\Program Files\NVIDIA\CUDNN"
-          if ("${{ steps.cache-install.outputs.cache-hit }}" -ne 'true') {
-            Invoke-WebRequest -Uri "${{ matrix.cudnn-install }}" -OutFile "cudnn.zip"
-            Expand-Archive -Path cudnn.zip -DestinationPath cudnn-extracted
-            $cudnnDir = (Get-ChildItem -Path cudnn-extracted -Directory)[0].FullName
-            New-Item -ItemType Directory -Force -Path $cudnnRoot
-            Copy-Item -Path "$cudnnDir\*" -Destination "$cudnnRoot\" -Recurse
-          }
-
-          echo "CUDNN_ROOT_DIR=$cudnnRoot" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_INCLUDE_PATH=$cudnnRoot\include" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "CUDNN_LIBRARY_PATH=$cudnnRoot\lib\x64" | Out-File -FilePath $env:GITHUB_ENV -Append
-          echo "$cudnnRoot\bin\x64" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
      - if: ${{ !cancelled() && steps.cache-install.outputs.cache-hit != 'true' }}
        uses: actions/cache/save@v4
        with:
@@ -229,8 +175,7 @@ jobs:
            C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA
            C:\Program Files\AMD\ROCm
            C:\VulkanSDK
-            C:\Program Files\NVIDIA\CUDNN
-          key: ${{ matrix.install }}-${{ matrix.cudnn-install }}
+          key: ${{ matrix.install }}
      - uses: actions/checkout@v4
      - uses: actions/cache@v4
        with:
@@ -240,7 +185,7 @@ jobs:
          Import-Module 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise\Common7\Tools\Microsoft.VisualStudio.DevShell.dll'
          Enter-VsDevShell -VsInstallPath 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' -SkipAutomaticLocation  -DevCmdArguments '-arch=x64 -no_logo'
          cmake --preset "${{ matrix.preset }}" ${{ matrix.flags }}
-          cmake --build --preset "${{ matrix.preset }}" -- -l $([Environment]::ProcessorCount)
+          cmake --build --parallel --preset "${{ matrix.preset }}"
        env:
          CMAKE_GENERATOR: Ninja

@@ -252,7 +197,6 @@ jobs:
        run: go mod tidy --diff || (echo "Please run 'go mod tidy'." && exit 1)

  test:
-    needs: [changes]
    strategy:
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
@@ -287,10 +231,6 @@ jobs:
        if: always()
        run: go test -count=1 -benchtime=1x ./...

-      - name: go test app with live updater tag
-        if: ${{ needs.changes.outputs.app_changed == 'True' && contains(fromJSON('["macos-latest","windows-latest"]'), matrix.os) }}
-        run: go test -count=1 -tags updater_live ./app/...
-
      - uses: golangci/golangci-lint-action@v9
        with:
          only-new-issues: true
@@ -15,4 +15,3 @@ __debug_bin*
 llama/build
 llama/vendor
 /ollama
-integration/testdata/models/
@@ -64,15 +64,10 @@ set(CMAKE_LIBRARY_OUTPUT_DIRECTORY         ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG   ${OLLAMA_BUILD_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${OLLAMA_BUILD_DIR})

-# Store ggml include paths for use with target_include_directories later.
-# We avoid global include_directories() to prevent polluting the include path
-# for other projects like MLX (whose openblas dependency has its own common.h).
-set(GGML_INCLUDE_DIRS
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu
-    ${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu/amx
-)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/include)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cpu/amx)

 add_compile_definitions(NDEBUG GGML_VERSION=0x0 GGML_COMMIT=0x0)

@@ -92,14 +87,6 @@ if(NOT CPU_VARIANTS)
    set(CPU_VARIANTS "ggml-cpu")
 endif()

-# Apply ggml include directories to ggml targets only (not globally)
-target_include_directories(ggml-base PRIVATE ${GGML_INCLUDE_DIRS})
-foreach(variant ${CPU_VARIANTS})
-    if(TARGET ${variant})
-        target_include_directories(${variant} PRIVATE ${GGML_INCLUDE_DIRS})
-    endif()
-endforeach()
-
 install(TARGETS ggml-base ${CPU_VARIANTS}
    RUNTIME_DEPENDENCIES
        PRE_EXCLUDE_REGEXES ".*"
@@ -116,7 +103,6 @@ if(CMAKE_CUDA_COMPILER)

    find_package(CUDAToolkit)
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-cuda)
-    target_include_directories(ggml-cuda PRIVATE ${GGML_INCLUDE_DIRS})
    install(TARGETS ggml-cuda
        RUNTIME_DEPENDENCIES
            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
@@ -148,7 +134,6 @@ if(CMAKE_HIP_COMPILER)
    if(AMDGPU_TARGETS)
        find_package(hip REQUIRED)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-hip)
-        target_include_directories(ggml-hip PRIVATE ${GGML_INCLUDE_DIRS})

        if (WIN32)
            target_compile_definitions(ggml-hip PRIVATE GGML_CUDA_NO_PEER_COPY)
@@ -163,7 +148,7 @@ if(CMAKE_HIP_COMPILER)
        )
        install(RUNTIME_DEPENDENCY_SET rocm
                DIRECTORIES ${HIP_BIN_INSTALL_DIR} ${HIP_LIB_INSTALL_DIR}
-                PRE_INCLUDE_REGEXES hipblas rocblas amdhip64 rocsolver amd_comgr hsa-runtime64 rocsparse tinfo rocprofiler-register roctx64 rocroller drm drm_amdgpu numa elf
+                PRE_INCLUDE_REGEXES hipblas rocblas amdhip64 rocsolver amd_comgr hsa-runtime64 rocsparse tinfo rocprofiler-register drm drm_amdgpu numa elf
                PRE_EXCLUDE_REGEXES ".*"
                POST_EXCLUDE_REGEXES "system32"
            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT HIP
@@ -183,7 +168,6 @@ if(NOT APPLE)
    find_package(Vulkan)
    if(Vulkan_FOUND)
        add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/ml/backend/ggml/ggml/src/ggml-vulkan)
-        target_include_directories(ggml-vulkan PRIVATE ${GGML_INCLUDE_DIRS})
        install(TARGETS ggml-vulkan
            RUNTIME_DEPENDENCIES
                PRE_INCLUDE_REGEXES vulkan
@@ -195,6 +179,7 @@ if(NOT APPLE)
 endif()

 option(MLX_ENGINE "Enable MLX backend" OFF)
+
 if(MLX_ENGINE)
    message(STATUS "Setting up MLX (this takes a while...)")
    add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/x/imagegen/mlx)
@@ -202,54 +187,15 @@ if(MLX_ENGINE)
    # Find CUDA toolkit if MLX is built with CUDA support
    find_package(CUDAToolkit)

-    # Build list of directories for runtime dependency resolution
-    set(MLX_RUNTIME_DIRS ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR})
-    # Add cuDNN bin paths for DLLs (Windows MLX CUDA builds)
-    # CUDNN_ROOT_DIR is the standard CMake variable for cuDNN location
-    if(DEFINED ENV{CUDNN_ROOT_DIR})
-        # cuDNN 9.x has versioned subdirectories under bin/ (e.g., bin/13.0/)
-        file(GLOB CUDNN_BIN_SUBDIRS "$ENV{CUDNN_ROOT_DIR}/bin/*")
-        list(APPEND MLX_RUNTIME_DIRS ${CUDNN_BIN_SUBDIRS})
-    endif()
-    # Add build output directory and MLX dependency build directories
-    list(APPEND MLX_RUNTIME_DIRS ${OLLAMA_BUILD_DIR})
-    # OpenBLAS DLL location (pre-built zip extracts into openblas-src/bin/)
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/openblas-src/bin)
-    # NCCL: on Linux, if real NCCL is found, cmake bundles libnccl.so via the
-    # regex below. If NCCL is not found, MLX links a static stub (OBJECT lib)
-    # so there is no runtime dependency. This path covers the stub build dir
-    # for windows so we include the DLL in our dependencies.
-    list(APPEND MLX_RUNTIME_DIRS ${CMAKE_BINARY_DIR}/_deps/mlx-build/mlx/distributed/nccl/nccl_stub-prefix/src/nccl_stub-build/Release)
-
-    # Base regexes for runtime dependencies (cross-platform)
-    set(MLX_INCLUDE_REGEXES cublas cublasLt cudart cufft nvrtc nvrtc-builtins cudnn nccl openblas gfortran)
-    # On Windows, also include dl.dll (dlfcn-win32 POSIX emulation layer)
-    if(WIN32)
-        list(APPEND MLX_INCLUDE_REGEXES "^dl\\.dll$")
-    endif()
-
-    # Split mlx/mlxc libraries from runtime deps to avoid stripping deps
    install(TARGETS mlx mlxc
-        RUNTIME_DEPENDENCY_SET mlx_runtime_deps
+        RUNTIME_DEPENDENCIES
+            DIRECTORIES ${CUDAToolkit_BIN_DIR} ${CUDAToolkit_BIN_DIR}/x64 ${CUDAToolkit_LIBRARY_DIR}
+            PRE_INCLUDE_REGEXES cublas cublasLt cudart nvrtc nvrtc-builtins cudnn nccl openblas gfortran
+            PRE_EXCLUDE_REGEXES ".*"
        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
        FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
    )
-    install(RUNTIME_DEPENDENCY_SET mlx_runtime_deps
-        DIRECTORIES ${MLX_RUNTIME_DIRS}
-        PRE_INCLUDE_REGEXES ${MLX_INCLUDE_REGEXES}
-        PRE_EXCLUDE_REGEXES ".*"
-        RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX_VENDOR
-        LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX_VENDOR
-    )
-
-    if(TARGET jaccl)
-        install(TARGETS jaccl
-            RUNTIME DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-            LIBRARY DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-            FRAMEWORK DESTINATION ${OLLAMA_INSTALL_DIR} COMPONENT MLX
-        )
-    endif()

    # Install the Metal library for macOS arm64 (must be colocated with the binary)
    # Metal backend is only built for arm64, not x86_64
@@ -259,119 +205,15 @@ if(MLX_ENGINE)
            COMPONENT MLX)
    endif()

-    # Install headers for NVRTC JIT compilation at runtime.
-    # MLX's own install rules use the default component so they get skipped by
-    # --component MLX. Headers are installed alongside libmlx in OLLAMA_INSTALL_DIR.
-    #
-    # Layout:
-    #   ${OLLAMA_INSTALL_DIR}/include/cccl/{cuda,nv}/  — CCCL headers
-    #   ${OLLAMA_INSTALL_DIR}/include/*.h               — CUDA toolkit headers
-    #
-    # MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir()[.parent_path()] / "include" / "cccl"
-    # On Linux, MLX's jit_module.cpp resolves CCCL via
-    #   current_binary_dir().parent_path() / "include" / "cccl", so we create a
-    #   symlink from lib/ollama/include -> ${OLLAMA_RUNNER_DIR}/include
-    #   This will need refinement if we add multiple CUDA versions for MLX in the future.
-    # CUDA runtime headers are found via CUDA_PATH env var (set by mlxrunner).
-    if(EXISTS ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/cuda
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        install(DIRECTORY ${CMAKE_BINARY_DIR}/_deps/cccl-src/include/nv
-            DESTINATION ${OLLAMA_INSTALL_DIR}/include/cccl
-            COMPONENT MLX)
-        if(NOT WIN32 AND NOT APPLE)
-            install(CODE "
-                set(_link \"${CMAKE_INSTALL_PREFIX}/lib/ollama/include\")
-                set(_target \"${OLLAMA_RUNNER_DIR}/include\")
-                if(NOT EXISTS \${_link})
-                    execute_process(COMMAND \${CMAKE_COMMAND} -E create_symlink \${_target} \${_link})
-                endif()
-            " COMPONENT MLX)
-        endif()
-    endif()
-
-    # Install minimal CUDA toolkit headers needed by MLX JIT kernels.
-    # These are the transitive closure of includes from mlx/backend/cuda/device/*.cuh.
-    # The Go mlxrunner sets CUDA_PATH to OLLAMA_INSTALL_DIR so MLX finds them at
-    # $CUDA_PATH/include/*.h via NVRTC --include-path.
+    # Manually install cudart and cublas since they might not be picked up as direct dependencies
    if(CUDAToolkit_FOUND)
-        # CUDAToolkit_INCLUDE_DIRS may be a semicolon-separated list
-        # (e.g. ".../include;.../include/cccl"). Find the entry that
-        # contains the CUDA runtime headers we need.
-        set(_cuda_inc "")
-        foreach(_dir ${CUDAToolkit_INCLUDE_DIRS})
-            if(EXISTS "${_dir}/cuda_runtime_api.h")
-                set(_cuda_inc "${_dir}")
-                break()
-            endif()
-        endforeach()
-        if(NOT _cuda_inc)
-            message(WARNING "Could not find cuda_runtime_api.h in CUDAToolkit_INCLUDE_DIRS: ${CUDAToolkit_INCLUDE_DIRS}")
-        else()
-            set(_dst "${OLLAMA_INSTALL_DIR}/include")
-            set(_MLX_JIT_CUDA_HEADERS
-                builtin_types.h
-                cooperative_groups.h
-                cuda_bf16.h
-                cuda_bf16.hpp
-                cuda_device_runtime_api.h
-                cuda_fp16.h
-                cuda_fp16.hpp
-                cuda_fp8.h
-                cuda_fp8.hpp
-                cuda_runtime_api.h
-                device_types.h
-                driver_types.h
-                math_constants.h
-                surface_types.h
-                texture_types.h
-                vector_functions.h
-                vector_functions.hpp
-                vector_types.h
-            )
-            foreach(_hdr ${_MLX_JIT_CUDA_HEADERS})
-                install(FILES "${_cuda_inc}/${_hdr}"
-                    DESTINATION ${_dst}
-                    COMPONENT MLX)
-            endforeach()
-            # Subdirectory headers
-            install(DIRECTORY "${_cuda_inc}/cooperative_groups"
-                DESTINATION ${_dst}
-                COMPONENT MLX
-                FILES_MATCHING PATTERN "*.h")
-            install(FILES "${_cuda_inc}/crt/host_defines.h"
-                DESTINATION "${_dst}/crt"
+        file(GLOB CUDART_LIBS
+            "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
+            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*")
+        if(CUDART_LIBS)
+            install(FILES ${CUDART_LIBS}
+                DESTINATION ${OLLAMA_INSTALL_DIR}
                COMPONENT MLX)
        endif()
    endif()
-
-    # On Windows, explicitly install dl.dll (dlfcn-win32 POSIX dlopen emulation)
-    # RUNTIME_DEPENDENCIES auto-excludes it via POST_EXCLUDE_FILES_STRICT because
-    # dlfcn-win32 is a known CMake target with its own install rules (which install
-    # to the wrong destination). We must install it explicitly here.
-    if(WIN32)
-        install(FILES ${OLLAMA_BUILD_DIR}/dl.dll
-            DESTINATION ${OLLAMA_INSTALL_DIR}
-            COMPONENT MLX)
-    endif()
-
-    # Manually install CUDA runtime libraries that MLX loads via dlopen
-    # (not detected by RUNTIME_DEPENDENCIES since they aren't link-time deps)
-    if(CUDAToolkit_FOUND)
-        file(GLOB MLX_CUDA_LIBS
-            "${CUDAToolkit_LIBRARY_DIR}/libcudart.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublas.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcublasLt.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libnvrtc-builtins.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcufft.so*"
-            "${CUDAToolkit_LIBRARY_DIR}/libcudnn.so*")
-        if(MLX_CUDA_LIBS)
-            install(FILES ${MLX_CUDA_LIBS}
-                DESTINATION ${OLLAMA_INSTALL_DIR}
-                COMPONENT MLX_VENDOR)
-        endif()
-    endif()
 endif()
@@ -41,7 +41,7 @@
      "inherits": [ "CUDA" ],
      "cacheVariables": {
        "CMAKE_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;87-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual",
-        "CMAKE_CUDA_FLAGS": "-t 2",
+        "CMAKE_CUDA_FLAGS": "-t 4",
        "OLLAMA_RUNNER_DIR": "cuda_v13"
      }
    },
@@ -77,15 +77,6 @@
        "OLLAMA_RUNNER_DIR": "rocm"
      }
    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "cacheVariables": {
-        "CMAKE_HIP_FLAGS": "-parallel-jobs=4",
-        "AMDGPU_TARGETS": "gfx942;gfx950;gfx1010;gfx1012;gfx1030;gfx1100;gfx1101;gfx1102;gfx1103;gfx1150;gfx1151;gfx1200;gfx1201;gfx908:xnack-;gfx90a:xnack+;gfx90a:xnack-",
-        "OLLAMA_RUNNER_DIR": "rocm"
-      }
-    },
    {
      "name": "Vulkan",
      "inherits": [ "Default" ],
@@ -112,7 +103,6 @@
      "name": "MLX CUDA 13",
      "inherits": [ "MLX", "CUDA 13" ],
      "cacheVariables": {
-        "MLX_CUDA_ARCHITECTURES": "75-virtual;80-virtual;86-virtual;89-virtual;90-virtual;90a-virtual;100-virtual;103-virtual;110-virtual;120-virtual;121-virtual",
        "OLLAMA_RUNNER_DIR": "mlx_cuda_v13"
      }
    }
@@ -168,11 +158,6 @@
      "inherits": [ "ROCm" ],
      "configurePreset": "ROCm 6"
    },
-    {
-      "name": "ROCm 7",
-      "inherits": [ "ROCm" ],
-      "configurePreset": "ROCm 7"
-    },
    {
      "name": "Vulkan",
      "targets": [ "ggml-vulkan" ],
@@ -1,23 +1,28 @@
 # vim: filetype=dockerfile

 ARG FLAVOR=${TARGETARCH}
+ARG PARALLEL=8

-ARG ROCMVERSION=7.2.1
+ARG ROCMVERSION=6.3.3
 ARG JETPACK5VERSION=r35.4.1
 ARG JETPACK6VERSION=r36.4.0
 ARG CMAKEVERSION=3.31.2
-ARG NINJAVERSION=1.12.1
 ARG VULKANVERSION=1.4.321.1

-# Default empty stages for local MLX source overrides.
-# Override with: docker build --build-context local-mlx=../mlx --build-context local-mlx-c=../mlx-c
-FROM scratch AS local-mlx
-FROM scratch AS local-mlx-c
-
 FROM --platform=linux/amd64 rocm/dev-almalinux-8:${ROCMVERSION}-complete AS base-amd64
 RUN dnf install -y yum-utils ccache gcc-toolset-11-gcc gcc-toolset-11-gcc-c++ gcc-toolset-11-binutils \
    && yum-config-manager --add-repo https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo
 ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
+ARG VULKANVERSION
+RUN wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && tar xvf /tmp/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz \
+    && dnf -y install ninja-build \
+    && ln -s /usr/bin/python3 /usr/bin/python \  
+    && /${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
+    && /${VULKANVERSION}/vulkansdk -j 8 shaderc
+RUN cp -r /${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
+    && cp -r /${VULKANVERSION}/x86_64/lib/* /usr/local/lib
+ENV PATH=/${VULKANVERSION}/x86_64/bin:$PATH

 FROM --platform=linux/arm64 almalinux:8 AS base-arm64
 # install epel-release for ccache
@@ -28,125 +33,103 @@ ENV CC=clang CXX=clang++

 FROM base-${TARGETARCH} AS base
 ARG CMAKEVERSION
-ARG NINJAVERSION
 RUN curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1
-RUN dnf install -y unzip \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux$([ "$(uname -m)" = "aarch64" ] && echo "-aarch64").zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
 ENV LDFLAGS=-s

 FROM base AS cpu
 RUN dnf install -y gcc-toolset-11-gcc gcc-toolset-11-gcc-c++
 ENV PATH=/opt/rh/gcc-toolset-11/root/usr/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CPU' \
-        && cmake --build --preset 'CPU' -- -l $(nproc) \
-        && cmake --install build --component CPU --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CPU' \
+        && cmake --install build --component CPU --strip --parallel ${PARALLEL}

 FROM base AS cuda-11
 ARG CUDA11VERSION=11.8
 RUN dnf install -y cuda-toolkit-${CUDA11VERSION//./-}
 ENV PATH=/usr/local/cuda-11/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 11' \
-        && cmake --build --preset 'CUDA 11' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 11' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM base AS cuda-12
 ARG CUDA12VERSION=12.8
 RUN dnf install -y cuda-toolkit-${CUDA12VERSION//./-}
 ENV PATH=/usr/local/cuda-12/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 12' \
-        && cmake --build --preset 'CUDA 12' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 12' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}


 FROM base AS cuda-13
 ARG CUDA13VERSION=13.0
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-}
 ENV PATH=/usr/local/cuda-13/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'CUDA 13' \
-        && cmake --build --preset 'CUDA 13' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'CUDA 13' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}


-FROM base AS rocm-7
+FROM base AS rocm-6
 ENV PATH=/opt/rocm/hcc/bin:/opt/rocm/hip/bin:/opt/rocm/bin:/opt/rocm/hcc/bin:$PATH
+ARG PARALLEL
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
-    cmake --preset 'ROCm 7' \
-        && cmake --build --preset 'ROCm 7' -- -l $(nproc) \
-        && cmake --install build --component HIP --strip
+    cmake --preset 'ROCm 6' \
+        && cmake --build --parallel ${PARALLEL} --preset 'ROCm 6' \
+        && cmake --install build --component HIP --strip --parallel ${PARALLEL}
 RUN rm -f dist/lib/ollama/rocm/rocblas/library/*gfx90[06]*

 FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK5VERSION} AS jetpack-5
 ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
+RUN apt-get update && apt-get install -y curl ccache \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'JetPack 5' \
-        && cmake --build --preset 'JetPack 5' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 5' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM --platform=linux/arm64 nvcr.io/nvidia/l4t-jetpack:${JETPACK6VERSION} AS jetpack-6
 ARG CMAKEVERSION
-ARG NINJAVERSION
-RUN apt-get update && apt-get install -y curl ccache unzip \
-    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1 \
-    && curl -fsSL -o /tmp/ninja.zip https://github.com/ninja-build/ninja/releases/download/v${NINJAVERSION}/ninja-linux-aarch64.zip \
-    && unzip /tmp/ninja.zip -d /usr/local/bin \
-    && rm /tmp/ninja.zip
-ENV CMAKE_GENERATOR=Ninja
+RUN apt-get update && apt-get install -y curl ccache \
+    && curl -fsSL https://github.com/Kitware/CMake/releases/download/v${CMAKEVERSION}/cmake-${CMAKEVERSION}-linux-$(uname -m).tar.gz | tar xz -C /usr/local --strip-components 1
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
+ARG PARALLEL
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'JetPack 6' \
-        && cmake --build --preset 'JetPack 6' -- -l $(nproc) \
-        && cmake --install build --component CUDA --strip
+        && cmake --build --parallel ${PARALLEL} --preset 'JetPack 6' \
+        && cmake --install build --component CUDA --strip --parallel ${PARALLEL}

 FROM base AS vulkan
-ARG VULKANVERSION
-RUN ln -s /usr/bin/python3 /usr/bin/python \
-    && wget https://sdk.lunarg.com/sdk/download/${VULKANVERSION}/linux/vulkansdk-linux-x86_64-${VULKANVERSION}.tar.xz -O /tmp/vulkansdk.tar.xz \
-    && tar xvf /tmp/vulkansdk.tar.xz -C /tmp \
-    && /tmp/${VULKANVERSION}/vulkansdk -j 8 vulkan-headers \
-    && /tmp/${VULKANVERSION}/vulkansdk -j 8 shaderc \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/include/* /usr/local/include/ \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/lib/* /usr/local/lib \
-    && cp -r /tmp/${VULKANVERSION}/x86_64/bin/* /usr/local/bin/ \
-    && rm -rf /tmp/${VULKANVERSION} /tmp/vulkansdk.tar.xz
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 RUN --mount=type=cache,target=/root/.ccache \
    cmake --preset 'Vulkan' \
-        && cmake --build --preset 'Vulkan' -- -l $(nproc) \
-        && cmake --install build --component Vulkan --strip
+        && cmake --build --parallel --preset 'Vulkan' \
+        && cmake --install build --component Vulkan --strip --parallel 8

 FROM base AS mlx
 ARG CUDA13VERSION=13.0
-#   OLLAMA_MLX_BUILD_JOBS  empty -> ninja gates by load average (-l $(nproc))
-ARG OLLAMA_MLX_BUILD_JOBS=
-ARG OLLAMA_MLX_NVCC_THREADS=2
 RUN dnf install -y cuda-toolkit-${CUDA13VERSION//./-} \
    && dnf install -y openblas-devel lapack-devel \
    && dnf install -y libcudnn9-cuda-13 libcudnn9-devel-cuda-13 \
@@ -155,28 +138,20 @@ ENV PATH=/usr/local/cuda-13/bin:$PATH
 ENV BLAS_INCLUDE_DIRS=/usr/include/openblas
 ENV LAPACK_INCLUDE_DIRS=/usr/include/openblas
 ENV CGO_LDFLAGS="-L/usr/local/cuda-13/lib64 -L/usr/local/cuda-13/targets/x86_64-linux/lib/stubs"
+ARG PARALLEL
 WORKDIR /go/src/github.com/ollama/ollama
 COPY CMakeLists.txt CMakePresets.json .
 COPY ml/backend/ggml/ggml ml/backend/ggml/ggml
 COPY x/imagegen/mlx x/imagegen/mlx
 COPY go.mod go.sum .
-COPY MLX_VERSION MLX_C_VERSION .
+COPY MLX_VERSION .
 RUN curl -fsSL https://golang.org/dl/go$(awk '/^go/ { print $2 }' go.mod).linux-$(case $(uname -m) in x86_64) echo amd64 ;; aarch64) echo arm64 ;; esac).tar.gz | tar xz -C /usr/local
 ENV PATH=/usr/local/go/bin:$PATH
 RUN go mod download
 RUN --mount=type=cache,target=/root/.ccache \
-    --mount=type=bind,from=local-mlx,target=/tmp/local-mlx \
-    --mount=type=bind,from=local-mlx-c,target=/tmp/local-mlx-c \
-    if [ -f /tmp/local-mlx/CMakeLists.txt ]; then \
-        export OLLAMA_MLX_SOURCE=/tmp/local-mlx; \
-    fi \
-    && if [ -f /tmp/local-mlx-c/CMakeLists.txt ]; then \
-        export OLLAMA_MLX_C_SOURCE=/tmp/local-mlx-c; \
-    fi \
-    && cmake --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas -DCMAKE_CUDA_FLAGS="-t ${OLLAMA_MLX_NVCC_THREADS}" \
-        && cmake --build --preset 'MLX CUDA 13' -- -l $(nproc) ${OLLAMA_MLX_BUILD_JOBS:+-j ${OLLAMA_MLX_BUILD_JOBS}} \
-        && cmake --install build --component MLX --strip \
-        && cmake --install build --component MLX_VENDOR
+    cmake --preset 'MLX CUDA 13' -DBLAS_INCLUDE_DIRS=/usr/include/openblas -DLAPACK_INCLUDE_DIRS=/usr/include/openblas \
+        && cmake --build --parallel ${PARALLEL} --preset 'MLX CUDA 13' \
+        && cmake --install build --component MLX --strip --parallel ${PARALLEL}

 FROM base AS build
 WORKDIR /go/src/github.com/ollama/ollama
@@ -185,14 +160,16 @@ RUN curl -fsSL https://golang.org/dl/go$(awk '/^go/ { print $2 }' go.mod).linux-
 ENV PATH=/usr/local/go/bin:$PATH
 RUN go mod download
 COPY . .
+# Clone mlx-c headers for CGO (version from MLX_VERSION file)
+RUN git clone --depth 1 --branch "$(cat MLX_VERSION)" https://github.com/ml-explore/mlx-c.git build/_deps/mlx-c-src
 ARG GOFLAGS="'-ldflags=-w -s'"
 ENV CGO_ENABLED=1
 ARG CGO_CFLAGS
 ARG CGO_CXXFLAGS
-ENV CGO_CFLAGS="${CGO_CFLAGS}"
+ENV CGO_CFLAGS="${CGO_CFLAGS} -I/go/src/github.com/ollama/ollama/build/_deps/mlx-c-src"
 ENV CGO_CXXFLAGS="${CGO_CXXFLAGS}"
 RUN --mount=type=cache,target=/root/.cache/go-build \
-    go build -trimpath -buildmode=pie -o /bin/ollama .
+    go build -tags mlx -trimpath -buildmode=pie -o /bin/ollama .

 FROM --platform=linux/amd64 scratch AS amd64
 # COPY --from=cuda-11 dist/lib/ollama/ /lib/ollama/
@@ -209,18 +186,16 @@ COPY --from=jetpack-5 dist/lib/ollama/ /lib/ollama/
 COPY --from=jetpack-6 dist/lib/ollama/ /lib/ollama/

 FROM scratch AS rocm
-COPY --from=rocm-7 dist/lib/ollama /lib/ollama
+COPY --from=rocm-6 dist/lib/ollama /lib/ollama

 FROM ${FLAVOR} AS archive
+ARG VULKANVERSION
 COPY --from=cpu dist/lib/ollama /lib/ollama
 COPY --from=build /bin/ollama /bin/ollama

 FROM ubuntu:24.04
-ARG APT_MIRROR=http://archive.ubuntu.com/ubuntu
-RUN sed -i "s|http://archive.ubuntu.com/ubuntu|$APT_MIRROR|g" /etc/apt/sources.list.d/ubuntu.sources \
-    && apt-get update \
+RUN apt-get update \
    && apt-get install -y ca-certificates libvulkan1 libopenblas0 \
-    && sed -i "s|$APT_MIRROR|http://archive.ubuntu.com/ubuntu|g" /etc/apt/sources.list.d/ubuntu.sources \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*
 COPY --from=archive /bin /usr/bin
@@ -1 +0,0 @@
-fba4470b89073180056c9ea46c443051375f7399
@@ -1 +1 @@
-e8ebdebeeb655feaa85a51f6b24ece5b6d5518d1
+v0.5.0
@@ -55,7 +55,7 @@ The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `olla
 ollama
 ```

-You'll be prompted to run a model or connect Ollama to your existing agents or applications such as `Claude Code`, `OpenClaw`, `OpenCode` , `Codex`, `Copilot`,  and more.
+You'll be prompted to run a model or connect Ollama to your existing agents or applications such as `claude`, `codex`, `openclaw` and more.

 ### Coding

@@ -65,7 +65,7 @@ To launch a specific integration:
 ollama launch claude
 ```

-Supported integrations include [Claude Code](https://docs.ollama.com/integrations/claude-code), [Codex](https://docs.ollama.com/integrations/codex), [Copilot CLI](https://docs.ollama.com/integrations/copilot-cli), [Droid](https://docs.ollama.com/integrations/droid), and [OpenCode](https://docs.ollama.com/integrations/opencode).
+Supported integrations include [Claude Code](https://docs.ollama.com/integrations/claude-code), [Codex](https://docs.ollama.com/integrations/codex), [Droid](https://docs.ollama.com/integrations/droid), and [OpenCode](https://docs.ollama.com/integrations/opencode).

 ### AI assistant

@@ -68,7 +68,7 @@ type MessagesRequest struct {
 	Model         string          `json:"model"`
 	MaxTokens     int             `json:"max_tokens"`
 	Messages      []MessageParam  `json:"messages"`
-	System        any             `json:"system,omitempty"` // string or []map[string]any (JSON-decoded ContentBlock)
+	System        any             `json:"system,omitempty"` // string or []ContentBlock
 	Stream        bool            `json:"stream,omitempty"`
 	Temperature   *float64        `json:"temperature,omitempty"`
 	TopP          *float64        `json:"top_p,omitempty"`
@@ -78,36 +78,12 @@ type MessagesRequest struct {
 	ToolChoice    *ToolChoice     `json:"tool_choice,omitempty"`
 	Thinking      *ThinkingConfig `json:"thinking,omitempty"`
 	Metadata      *Metadata       `json:"metadata,omitempty"`
-	OutputConfig  *OutputConfig   `json:"output_config,omitempty"`
-}
-
-type OutputConfig struct {
-	Effort string `json:"effort,omitempty"`
 }

 // MessageParam represents a message in the request
 type MessageParam struct {
-	Role    string         `json:"role"`    // "user" or "assistant"
-	Content []ContentBlock `json:"content"` // always []ContentBlock; plain strings are normalized on unmarshal
-}
-
-func (m *MessageParam) UnmarshalJSON(data []byte) error {
-	var raw struct {
-		Role    string          `json:"role"`
-		Content json.RawMessage `json:"content"`
-	}
-	if err := json.Unmarshal(data, &raw); err != nil {
-		return err
-	}
-	m.Role = raw.Role
-
-	var s string
-	if err := json.Unmarshal(raw.Content, &s); err == nil {
-		m.Content = []ContentBlock{{Type: "text", Text: &s}}
-		return nil
-	}
-
-	return json.Unmarshal(raw.Content, &m.Content)
+	Role    string `json:"role"`    // "user" or "assistant"
+	Content any    `json:"content"` // string or []ContentBlock
 }

 // ContentBlock represents a content block in a message.
@@ -126,9 +102,9 @@ type ContentBlock struct {
 	Source *ImageSource `json:"source,omitempty"`

 	// For tool_use and server_tool_use blocks
-	ID    string                        `json:"id,omitempty"`
-	Name  string                        `json:"name,omitempty"`
-	Input api.ToolCallFunctionArguments `json:"input,omitzero"`
+	ID    string `json:"id,omitempty"`
+	Name  string `json:"name,omitempty"`
+	Input any    `json:"input,omitempty"`

 	// For tool_result and web_search_tool_result blocks
 	ToolUseID string `json:"tool_use_id,omitempty"`
@@ -166,7 +142,7 @@ type WebSearchToolResultError struct {

 // ImageSource represents the source of an image
 type ImageSource struct {
-	Type      string `json:"type"` // "base64"
+	Type      string `json:"type"` // "base64" or "url"
 	MediaType string `json:"media_type,omitempty"`
 	Data      string `json:"data,omitempty"`
 	URL       string `json:"url,omitempty"`
@@ -378,26 +354,9 @@ func FromMessagesRequest(r MessagesRequest) (*api.ChatRequest, error) {
 	}

 	var think *api.ThinkValue
-	normalizedEffort := ""
-	if r.OutputConfig != nil {
-		normalizedEffort = strings.ToLower(strings.TrimSpace(r.OutputConfig.Effort))
-		if normalizedEffort == "xhigh" {
-			normalizedEffort = "high"
-		}
-	}
-
 	if r.Thinking != nil && r.Thinking.Type == "enabled" {
 		think = &api.ThinkValue{Value: true}
 	}
-	if r.Thinking != nil && r.Thinking.Type == "disabled" {
-		think = &api.ThinkValue{Value: false}
-	}
-	if think == nil && r.OutputConfig != nil {
-		switch normalizedEffort {
-		case "high", "medium", "low", "max":
-			think = &api.ThinkValue{Value: normalizedEffort}
-		}
-	}

 	stream := r.Stream
 	convertedRequest := &api.ChatRequest{
@@ -418,135 +377,177 @@ func convertMessage(msg MessageParam) ([]api.Message, error) {
 	var messages []api.Message
 	role := strings.ToLower(msg.Role)

-	var textContent strings.Builder
-	var images []api.ImageData
-	var toolCalls []api.ToolCall
-	var thinking string
-	var toolResults []api.Message
-	textBlocks := 0
-	imageBlocks := 0
-	toolUseBlocks := 0
-	toolResultBlocks := 0
-	serverToolUseBlocks := 0
-	webSearchToolResultBlocks := 0
-	thinkingBlocks := 0
-	unknownBlocks := 0
+	switch content := msg.Content.(type) {
+	case string:
+		messages = append(messages, api.Message{Role: role, Content: content})

-	for _, block := range msg.Content {
-		switch block.Type {
-		case "text":
-			textBlocks++
-			if block.Text != nil {
-				textContent.WriteString(*block.Text)
+	case []any:
+		var textContent strings.Builder
+		var images []api.ImageData
+		var toolCalls []api.ToolCall
+		var thinking string
+		var toolResults []api.Message
+		textBlocks := 0
+		imageBlocks := 0
+		toolUseBlocks := 0
+		toolResultBlocks := 0
+		serverToolUseBlocks := 0
+		webSearchToolResultBlocks := 0
+		thinkingBlocks := 0
+		unknownBlocks := 0
+
+		for _, block := range content {
+			blockMap, ok := block.(map[string]any)
+			if !ok {
+				logutil.Trace("anthropic: invalid content block format", "role", role)
+				return nil, errors.New("invalid content block format")
 			}

-		case "image":
-			imageBlocks++
-			if block.Source == nil {
-				logutil.Trace("anthropic: invalid image source", "role", role)
-				return nil, errors.New("invalid image source")
+			blockType, _ := blockMap["type"].(string)
+
+			switch blockType {
+			case "text":
+				textBlocks++
+				if text, ok := blockMap["text"].(string); ok {
+					textContent.WriteString(text)
+				}
+
+			case "image":
+				imageBlocks++
+				source, ok := blockMap["source"].(map[string]any)
+				if !ok {
+					logutil.Trace("anthropic: invalid image source", "role", role)
+					return nil, errors.New("invalid image source")
+				}
+
+				sourceType, _ := source["type"].(string)
+				if sourceType == "base64" {
+					data, _ := source["data"].(string)
+					decoded, err := base64.StdEncoding.DecodeString(data)
+					if err != nil {
+						logutil.Trace("anthropic: invalid base64 image data", "role", role, "error", err)
+						return nil, fmt.Errorf("invalid base64 image data: %w", err)
+					}
+					images = append(images, decoded)
+				} else {
+					logutil.Trace("anthropic: unsupported image source type", "role", role, "source_type", sourceType)
+					return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", sourceType)
+				}
+				// URL images would need to be fetched - skip for now
+
+			case "tool_use":
+				toolUseBlocks++
+				id, ok := blockMap["id"].(string)
+				if !ok {
+					logutil.Trace("anthropic: tool_use block missing id", "role", role)
+					return nil, errors.New("tool_use block missing required 'id' field")
+				}
+				name, ok := blockMap["name"].(string)
+				if !ok {
+					logutil.Trace("anthropic: tool_use block missing name", "role", role)
+					return nil, errors.New("tool_use block missing required 'name' field")
+				}
+				tc := api.ToolCall{
+					ID: id,
+					Function: api.ToolCallFunction{
+						Name: name,
+					},
+				}
+				if input, ok := blockMap["input"].(map[string]any); ok {
+					tc.Function.Arguments = mapToArgs(input)
+				}
+				toolCalls = append(toolCalls, tc)
+
+			case "tool_result":
+				toolResultBlocks++
+				toolUseID, _ := blockMap["tool_use_id"].(string)
+				var resultContent string
+
+				switch c := blockMap["content"].(type) {
+				case string:
+					resultContent = c
+				case []any:
+					for _, cb := range c {
+						if cbMap, ok := cb.(map[string]any); ok {
+							if cbMap["type"] == "text" {
+								if text, ok := cbMap["text"].(string); ok {
+									resultContent += text
+								}
+							}
+						}
+					}
+				}
+
+				toolResults = append(toolResults, api.Message{
+					Role:       "tool",
+					Content:    resultContent,
+					ToolCallID: toolUseID,
+				})
+
+			case "thinking":
+				thinkingBlocks++
+				if t, ok := blockMap["thinking"].(string); ok {
+					thinking = t
+				}
+
+			case "server_tool_use":
+				serverToolUseBlocks++
+				id, _ := blockMap["id"].(string)
+				name, _ := blockMap["name"].(string)
+				tc := api.ToolCall{
+					ID: id,
+					Function: api.ToolCallFunction{
+						Name: name,
+					},
+				}
+				if input, ok := blockMap["input"].(map[string]any); ok {
+					tc.Function.Arguments = mapToArgs(input)
+				}
+				toolCalls = append(toolCalls, tc)
+
+			case "web_search_tool_result":
+				webSearchToolResultBlocks++
+				toolUseID, _ := blockMap["tool_use_id"].(string)
+				toolResults = append(toolResults, api.Message{
+					Role:       "tool",
+					Content:    formatWebSearchToolResultContent(blockMap["content"]),
+					ToolCallID: toolUseID,
+				})
+			default:
+				unknownBlocks++
 			}
-
-			decoded, err := resolveImageSource(block.Source)
-			if err != nil {
-				logutil.Trace("anthropic: unsupported image source", "role", role, "source_type", block.Source.Type, "error", err)
-				return nil, err
-			}
-			images = append(images, decoded)
-
-		case "tool_use":
-			toolUseBlocks++
-			if block.ID == "" {
-				logutil.Trace("anthropic: tool_use block missing id", "role", role)
-				return nil, errors.New("tool_use block missing required 'id' field")
-			}
-			if block.Name == "" {
-				logutil.Trace("anthropic: tool_use block missing name", "role", role)
-				return nil, errors.New("tool_use block missing required 'name' field")
-			}
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "tool_result":
-			toolResultBlocks++
-			resultContent, resultImages, err := convertToolResultContent(block.Content)
-			if err != nil {
-				logutil.Trace("anthropic: invalid tool_result content", "role", role, "error", err)
-				return nil, err
-			}
-
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    resultContent,
-				Images:     resultImages,
-				ToolCallID: block.ToolUseID,
-			})
-
-		case "thinking":
-			thinkingBlocks++
-			if block.Thinking != nil {
-				thinking = *block.Thinking
-			}
-
-		case "server_tool_use":
-			serverToolUseBlocks++
-			toolCalls = append(toolCalls, api.ToolCall{
-				ID: block.ID,
-				Function: api.ToolCallFunction{
-					Name:      block.Name,
-					Arguments: block.Input,
-				},
-			})
-
-		case "web_search_tool_result":
-			webSearchToolResultBlocks++
-			toolResults = append(toolResults, api.Message{
-				Role:       "tool",
-				Content:    formatWebSearchToolResultContent(block.Content),
-				ToolCallID: block.ToolUseID,
-			})
-		default:
-			unknownBlocks++
 		}
-	}

-	if role == "user" && len(toolResults) > 0 {
-		messages = append(messages, toolResults...)
-	}
-
-	if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
-		m := api.Message{
-			Role:      role,
-			Content:   textContent.String(),
-			Images:    images,
-			ToolCalls: toolCalls,
-			Thinking:  thinking,
+		if textContent.Len() > 0 || len(images) > 0 || len(toolCalls) > 0 || thinking != "" {
+			m := api.Message{
+				Role:      role,
+				Content:   textContent.String(),
+				Images:    images,
+				ToolCalls: toolCalls,
+				Thinking:  thinking,
+			}
+			messages = append(messages, m)
 		}
-		messages = append(messages, m)
-	}

-	// Add tool results as separate messages.
-	if role != "user" || len(toolResults) == 0 {
+		// Add tool results as separate messages
 		messages = append(messages, toolResults...)
+		logutil.Trace("anthropic: converted block message",
+			"role", role,
+			"blocks", len(content),
+			"text", textBlocks,
+			"image", imageBlocks,
+			"tool_use", toolUseBlocks,
+			"tool_result", toolResultBlocks,
+			"server_tool_use", serverToolUseBlocks,
+			"web_search_result", webSearchToolResultBlocks,
+			"thinking", thinkingBlocks,
+			"unknown", unknownBlocks,
+			"messages", TraceAPIMessages(messages),
+		)
+
+	default:
+		return nil, fmt.Errorf("invalid message content type: %T", content)
 	}
-	logutil.Trace("anthropic: converted block message",
-		"role", role,
-		"blocks", len(msg.Content),
-		"text", textBlocks,
-		"image", imageBlocks,
-		"tool_use", toolUseBlocks,
-		"tool_result", toolResultBlocks,
-		"server_tool_use", serverToolUseBlocks,
-		"web_search_result", webSearchToolResultBlocks,
-		"thinking", thinkingBlocks,
-		"unknown", unknownBlocks,
-		"messages", TraceAPIMessages(messages),
-	)

 	return messages, nil
 }
@@ -851,19 +852,6 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			continue
 		}

-		// Close thinking block if still open (thinking → tool_use without text in between)
-		if c.thinkingStarted && !c.thinkingDone {
-			c.thinkingDone = true
-			events = append(events, StreamEvent{
-				Event: "content_block_stop",
-				Data: ContentBlockStopEvent{
-					Type:  "content_block_stop",
-					Index: c.contentIndex,
-				},
-			})
-			c.contentIndex++
-		}
-
 		if c.textStarted {
 			events = append(events, StreamEvent{
 				Event: "content_block_stop",
@@ -881,6 +869,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 			slog.Error("failed to marshal tool arguments", "error", err, "tool_id", tc.ID)
 			continue
 		}
+
 		events = append(events, StreamEvent{
 			Event: "content_block_start",
 			Data: ContentBlockStartEvent{
@@ -890,7 +879,7 @@ func (c *StreamConverter) Process(r api.ChatResponse) []StreamEvent {
 					Type:  "tool_use",
 					ID:    tc.ID,
 					Name:  tc.Function.Name,
-					Input: api.NewToolCallFunctionArguments(),
+					Input: map[string]any{},
 				},
 			},
 		})
@@ -982,76 +971,20 @@ func GenerateMessageID() string {
 	return generateID("msg")
 }

-func resolveImageSource(source *ImageSource) (api.ImageData, error) {
-	if source.Type != "base64" {
-		return nil, fmt.Errorf("invalid image source type: %s. Only base64 images are supported.", source.Type)
-	}
-
-	decoded, err := base64.StdEncoding.DecodeString(source.Data)
-	if err != nil {
-		return nil, fmt.Errorf("invalid base64 image data: %w", err)
-	}
-
-	return decoded, nil
-}
-
-func convertToolResultContent(content any) (string, []api.ImageData, error) {
-	switch c := content.(type) {
-	case nil:
-		return "", nil, nil
-	case string:
-		return c, nil, nil
-	case []any:
-		var text strings.Builder
-		var images []api.ImageData
-
-		for _, cb := range c {
-			cbMap, ok := cb.(map[string]any)
-			if !ok {
-				continue
-			}
-
-			switch cbMap["type"] {
-			case "text":
-				if t, ok := cbMap["text"].(string); ok {
-					text.WriteString(t)
-				}
-			case "image":
-				rawSource, ok := cbMap["source"].(map[string]any)
-				if !ok {
-					return "", nil, errors.New("invalid tool_result image source")
-				}
-
-				var source ImageSource
-				if rawType, ok := rawSource["type"].(string); ok {
-					source.Type = rawType
-				}
-				if rawMediaType, ok := rawSource["media_type"].(string); ok {
-					source.MediaType = rawMediaType
-				}
-				if rawData, ok := rawSource["data"].(string); ok {
-					source.Data = rawData
-				}
-
-				img, err := resolveImageSource(&source)
-				if err != nil {
-					return "", nil, err
-				}
-				images = append(images, img)
-			}
-		}
-
-		return text.String(), images, nil
-	default:
-		return "", nil, nil
-	}
-}
-
 // ptr returns a pointer to the given string value
 func ptr(s string) *string {
 	return &s
 }

+// mapToArgs converts a map to ToolCallFunctionArguments
+func mapToArgs(m map[string]any) api.ToolCallFunctionArguments {
+	args := api.NewToolCallFunctionArguments()
+	for k, v := range m {
+		args.Set(k, v)
+	}
+	return args
+}
+
 // CountTokensRequest represents an Anthropic count_tokens request
 type CountTokensRequest struct {
 	Model    string          `json:"model"`
@@ -1084,13 +1017,17 @@ func estimateTokens(req CountTokensRequest) int {
 	var totalLen int

 	// Count system prompt
-	totalLen += countAnyContent(req.System)
+	if req.System != nil {
+		totalLen += countAnyContent(req.System)
+	}

+	// Count messages
 	for _, msg := range req.Messages {
 		// Count role (always present)
 		totalLen += len(msg.Role)
 		// Count content
-		totalLen += countAnyContent(msg.Content)
+		contentLen := countAnyContent(msg.Content)
+		totalLen += contentLen
 	}

 	for _, tool := range req.Tools {
@@ -1113,25 +1050,12 @@ func countAnyContent(content any) int {
 	switch c := content.(type) {
 	case string:
 		return len(c)
-	case []ContentBlock:
+	case []any:
 		total := 0
 		for _, block := range c {
 			total += countContentBlock(block)
 		}
 		return total
-	case []any:
-		total := 0
-		for _, item := range c {
-			data, err := json.Marshal(item)
-			if err != nil {
-				continue
-			}
-			var block ContentBlock
-			if err := json.Unmarshal(data, &block); err == nil {
-				total += countContentBlock(block)
-			}
-		}
-		return total
 	default:
 		if data, err := json.Marshal(content); err == nil {
 			return len(data)
@@ -1140,19 +1064,38 @@ func countAnyContent(content any) int {
 	}
 }

-func countContentBlock(block ContentBlock) int {
+func countContentBlock(block any) int {
+	blockMap, ok := block.(map[string]any)
+	if !ok {
+		if s, ok := block.(string); ok {
+			return len(s)
+		}
+		return 0
+	}
+
 	total := 0
-	if block.Text != nil {
-		total += len(*block.Text)
+	blockType, _ := blockMap["type"].(string)
+
+	if text, ok := blockMap["text"].(string); ok {
+		total += len(text)
 	}
-	if block.Thinking != nil {
-		total += len(*block.Thinking)
+
+	if thinking, ok := blockMap["thinking"].(string); ok {
+		total += len(thinking)
 	}
-	if block.Type == "tool_use" || block.Type == "tool_result" {
-		if data, err := json.Marshal(block); err == nil {
+
+	if blockType == "tool_use" {
+		if data, err := json.Marshal(blockMap); err == nil {
 			total += len(data)
 		}
 	}
+
+	if blockType == "tool_result" {
+		if data, err := json.Marshal(blockMap); err == nil {
+			total += len(data)
+		}
+	}
+
 	return total
 }

@@ -15,16 +15,11 @@ const (
 	testImage = `iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=`
 )

-// textContent is a convenience for constructing []ContentBlock with a single text block in tests.
-func textContent(s string) []ContentBlock {
-	return []ContentBlock{{Type: "text", Text: &s}}
-}
-
-// makeArgs creates ToolCallFunctionArguments from key-value pairs (convenience function for tests)
-func makeArgs(kvs ...any) api.ToolCallFunctionArguments {
+// testArgs creates ToolCallFunctionArguments from a map (convenience function for tests)
+func testArgs(m map[string]any) api.ToolCallFunctionArguments {
 	args := api.NewToolCallFunctionArguments()
-	for i := 0; i < len(kvs)-1; i += 2 {
-		args.Set(kvs[i].(string), kvs[i+1])
+	for k, v := range m {
+		args.Set(k, v)
 	}
 	return args
 }
@@ -34,7 +29,7 @@ func TestFromMessagesRequest_Basic(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -66,7 +61,7 @@ func TestFromMessagesRequest_WithSystemPrompt(t *testing.T) {
 		MaxTokens: 1024,
 		System:    "You are a helpful assistant.",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -93,7 +88,7 @@ func TestFromMessagesRequest_WithSystemPromptArray(t *testing.T) {
 			map[string]any{"type": "text", "text": " Be concise."},
 		},
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -118,7 +113,7 @@ func TestFromMessagesRequest_WithOptions(t *testing.T) {
 	req := MessagesRequest{
 		Model:         "test-model",
 		MaxTokens:     2048,
-		Messages:      []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:      []MessageParam{{Role: "user", Content: "Hello"}},
 		Temperature:   &temp,
 		TopP:          &topP,
 		TopK:          &topK,
@@ -153,14 +148,14 @@ func TestFromMessagesRequest_WithImage(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "user",
-				Content: []ContentBlock{
-					{Type: "text", Text: ptr("What's in this image?")},
-					{
-						Type: "image",
-						Source: &ImageSource{
-							Type:      "base64",
-							MediaType: "image/png",
-							Data:      testImage,
+				Content: []any{
+					map[string]any{"type": "text", "text": "What's in this image?"},
+					map[string]any{
+						"type": "image",
+						"source": map[string]any{
+							"type":       "base64",
+							"media_type": "image/png",
+							"data":       testImage,
 						},
 					},
 				},
@@ -195,15 +190,15 @@ func TestFromMessagesRequest_WithToolUse(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather in Paris?")},
+			{Role: "user", Content: "What's the weather in Paris?"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:  "tool_use",
-						ID:    "call_123",
-						Name:  "get_weather",
-						Input: makeArgs("location", "Paris"),
+				Content: []any{
+					map[string]any{
+						"type":  "tool_use",
+						"id":    "call_123",
+						"name":  "get_weather",
+						"input": map[string]any{"location": "Paris"},
 					},
 				},
 			},
@@ -239,11 +234,11 @@ func TestFromMessagesRequest_WithToolResult(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_123",
-						Content:   "The weather in Paris is sunny, 22°C",
+				Content: []any{
+					map[string]any{
+						"type":        "tool_result",
+						"tool_use_id": "call_123",
+						"content":     "The weather in Paris is sunny, 22°C",
 					},
 				},
 			},
@@ -271,246 +266,11 @@ func TestFromMessagesRequest_WithToolResult(t *testing.T) {
 	}
 }

-func TestFromMessagesRequest_WithToolResultImage(t *testing.T) {
-	imgData, _ := base64.StdEncoding.DecodeString(testImage)
-
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_img",
-						Content: []any{
-							map[string]any{"type": "text", "text": "Attached image"},
-							map[string]any{
-								"type": "image",
-								"source": map[string]any{
-									"type":       "base64",
-									"media_type": "image/png",
-									"data":       testImage,
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 1 {
-		t.Fatalf("expected 1 message, got %d", len(result.Messages))
-	}
-
-	msg := result.Messages[0]
-	if msg.Role != "tool" {
-		t.Errorf("expected role 'tool', got %q", msg.Role)
-	}
-	if msg.ToolCallID != "call_img" {
-		t.Errorf("expected tool_call_id 'call_img', got %q", msg.ToolCallID)
-	}
-	if msg.Content != "Attached image" {
-		t.Errorf("unexpected content: %q", msg.Content)
-	}
-	if len(msg.Images) != 1 {
-		t.Fatalf("expected 1 image, got %d", len(msg.Images))
-	}
-	if string(msg.Images[0]) != string(imgData) {
-		t.Error("image data mismatch")
-	}
-}
-
-func TestFromMessagesRequest_WithToolResultFollowedByUserText(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "test-model",
-		MaxTokens: 1024,
-		Messages: []MessageParam{
-			{
-				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:  "tool_use",
-						ID:    "call_read",
-						Name:  "Read",
-						Input: makeArgs("file_path", "/Users/hoyyeva/Desktop/aaa.png"),
-					},
-				},
-			},
-			{
-				Role: "user",
-				Content: []ContentBlock{
-					{
-						Type:      "tool_result",
-						ToolUseID: "call_read",
-						Content:   "Read image (311.5KB)",
-					},
-					{
-						Type: "text",
-						Text: ptr("Please describe it."),
-					},
-				},
-			},
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if len(result.Messages) != 3 {
-		t.Fatalf("expected 3 messages, got %d", len(result.Messages))
-	}
-
-	if result.Messages[1].Role != "tool" {
-		t.Fatalf("expected second message to be tool, got %q", result.Messages[1].Role)
-	}
-	if result.Messages[1].ToolCallID != "call_read" {
-		t.Fatalf("expected tool_call_id 'call_read', got %q", result.Messages[1].ToolCallID)
-	}
-	if result.Messages[2].Role != "user" {
-		t.Fatalf("expected third message to be user, got %q", result.Messages[2].Role)
-	}
-	if result.Messages[2].Content != "Please describe it." {
-		t.Fatalf("unexpected user content: %q", result.Messages[2].Content)
-	}
-}
-
-func TestFromMessagesRequest_WithOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high', got %q", got)
-	}
-}
-
-func TestFromMessagesRequest_WithOutputConfigEffortXHighMapsToHigh(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "xhigh",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high' for xhigh effort, got %q", got)
-	}
-}
-
-func TestFromMessagesRequest_ThinkingDisabledOverridesOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		Thinking: &ThinkingConfig{
-			Type: "disabled",
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set")
-	}
-
-	if got := result.Think.Value; got != false {
-		t.Fatalf("expected think=false when thinking is disabled, got %v", got)
-	}
-}
-
-func TestFromMessagesRequest_ThinkingAdaptiveUsesOutputConfigEffort(t *testing.T) {
-	req := MessagesRequest{
-		Model:     "gemma4",
-		MaxTokens: 32000,
-		Messages: []MessageParam{
-			{
-				Role:    "user",
-				Content: textContent("Describe the image."),
-			},
-		},
-		Thinking: &ThinkingConfig{
-			Type: "adaptive",
-		},
-		OutputConfig: &OutputConfig{
-			Effort: "high",
-		},
-	}
-
-	result, err := FromMessagesRequest(req)
-	if err != nil {
-		t.Fatalf("unexpected error: %v", err)
-	}
-
-	if result.Think == nil {
-		t.Fatal("expected think to be set from output_config.effort")
-	}
-
-	if got := result.Think.String(); got != "high" {
-		t.Fatalf("expected think level 'high' for adaptive thinking, got %q", got)
-	}
-}
-
 func TestFromMessagesRequest_WithTools(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Name:        "get_weather",
@@ -545,7 +305,7 @@ func TestFromMessagesRequest_DropsCustomWebSearchWhenBuiltinPresent(t *testing.T
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Type: "web_search_20250305",
@@ -586,7 +346,7 @@ func TestFromMessagesRequest_KeepsCustomWebSearchWhenBuiltinAbsent(t *testing.T)
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Type:        "custom",
@@ -617,7 +377,7 @@ func TestFromMessagesRequest_WithThinking(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Thinking:  &ThinkingConfig{Type: "enabled", BudgetTokens: 1000},
 	}

@@ -639,13 +399,13 @@ func TestFromMessagesRequest_ThinkingOnlyBlock(t *testing.T) {
 		Model:     "test-model",
 		MaxTokens: 1024,
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this..."),
+				Content: []any{
+					map[string]any{
+						"type":     "thinking",
+						"thinking": "Let me think about this...",
 					},
 				},
 			},
@@ -674,10 +434,10 @@ func TestFromMessagesRequest_ToolUseMissingID(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						Name: "get_weather",
+				Content: []any{
+					map[string]any{
+						"type": "tool_use",
+						"name": "get_weather",
 					},
 				},
 			},
@@ -700,10 +460,10 @@ func TestFromMessagesRequest_ToolUseMissingName(t *testing.T) {
 		Messages: []MessageParam{
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type: "tool_use",
-						ID:   "call_123",
+				Content: []any{
+					map[string]any{
+						"type": "tool_use",
+						"id":   "call_123",
 					},
 				},
 			},
@@ -723,7 +483,7 @@ func TestFromMessagesRequest_InvalidToolSchema(t *testing.T) {
 	req := MessagesRequest{
 		Model:     "test-model",
 		MaxTokens: 1024,
-		Messages:  []MessageParam{{Role: "user", Content: textContent("Hello")}},
+		Messages:  []MessageParam{{Role: "user", Content: "Hello"}},
 		Tools: []Tool{
 			{
 				Name:        "bad_tool",
@@ -788,7 +548,7 @@ func TestToMessagesResponse_WithToolCalls(t *testing.T) {
 					ID: "call_123",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 			},
@@ -1000,7 +760,7 @@ func TestStreamConverter_WithToolCalls(t *testing.T) {
 					ID: "call_123",
 					Function: api.ToolCallFunction{
 						Name:      "get_weather",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 			},
@@ -1039,107 +799,6 @@ func TestStreamConverter_WithToolCalls(t *testing.T) {
 	}
 }

-// TestStreamConverter_ThinkingDirectlyFollowedByToolCall verifies that when a
-// model emits a thinking block followed directly by a tool_use block (with no
-// text block in between), the streaming converter correctly closes the thinking
-// block and increments the content index before opening the tool_use block.
-// Previously, the converter reused contentIndex=0 for the tool_use block,
-// which caused "Content block not found" errors in clients. See #14816.
-func TestStreamConverter_ThinkingDirectlyFollowedByToolCall(t *testing.T) {
-	conv := NewStreamConverter("msg_123", "test-model", 0)
-
-	// First chunk: thinking content (no text)
-	resp1 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role:     "assistant",
-			Thinking: "I should call the tool.",
-		},
-	}
-	events1 := conv.Process(resp1)
-
-	// Should have: message_start, content_block_start(thinking), content_block_delta(thinking)
-	if len(events1) < 3 {
-		t.Fatalf("expected at least 3 events for thinking chunk, got %d", len(events1))
-	}
-	if events1[0].Event != "message_start" {
-		t.Errorf("expected first event 'message_start', got %q", events1[0].Event)
-	}
-	thinkingStart, ok := events1[1].Data.(ContentBlockStartEvent)
-	if !ok || thinkingStart.ContentBlock.Type != "thinking" {
-		t.Errorf("expected content_block_start(thinking) as second event, got %+v", events1[1])
-	}
-	if thinkingStart.Index != 0 {
-		t.Errorf("expected thinking block at index 0, got %d", thinkingStart.Index)
-	}
-
-	// Second chunk: tool call (no text between thinking and tool)
-	resp2 := api.ChatResponse{
-		Model: "test-model",
-		Message: api.Message{
-			Role: "assistant",
-			ToolCalls: []api.ToolCall{
-				{
-					ID: "call_abc",
-					Function: api.ToolCallFunction{
-						Name:      "ask_user",
-						Arguments: makeArgs("question", "cats or dogs?"),
-					},
-				},
-			},
-		},
-		Done:       true,
-		DoneReason: "stop",
-		Metrics:    api.Metrics{PromptEvalCount: 10, EvalCount: 5},
-	}
-	events2 := conv.Process(resp2)
-
-	// Expect: content_block_stop(index=0), content_block_start(tool_use, index=1),
-	//         content_block_delta(input_json_delta, index=1), content_block_stop(index=1),
-	//         message_delta, message_stop
-	var thinkingStop, toolStart, toolDelta, toolStop *StreamEvent
-	for i := range events2 {
-		e := &events2[i]
-		switch e.Event {
-		case "content_block_stop":
-			if stop, ok := e.Data.(ContentBlockStopEvent); ok {
-				if stop.Index == 0 && thinkingStop == nil {
-					thinkingStop = e
-				} else if stop.Index == 1 {
-					toolStop = e
-				}
-			}
-		case "content_block_start":
-			if start, ok := e.Data.(ContentBlockStartEvent); ok && start.ContentBlock.Type == "tool_use" {
-				toolStart = e
-			}
-		case "content_block_delta":
-			if delta, ok := e.Data.(ContentBlockDeltaEvent); ok && delta.Delta.Type == "input_json_delta" {
-				toolDelta = e
-			}
-		}
-	}
-
-	if thinkingStop == nil {
-		t.Error("expected content_block_stop for thinking block (index 0)")
-	}
-	if toolStart == nil {
-		t.Fatal("expected content_block_start for tool_use block")
-	}
-	if start, ok := toolStart.Data.(ContentBlockStartEvent); !ok || start.Index != 1 {
-		t.Errorf("expected tool_use block at index 1, got %+v", toolStart.Data)
-	}
-	if toolDelta == nil {
-		t.Fatal("expected input_json_delta event for tool call")
-	}
-	if delta, ok := toolDelta.Data.(ContentBlockDeltaEvent); !ok || delta.Index != 1 {
-		t.Errorf("expected tool delta at index 1, got %+v", toolDelta.Data)
-	}
-	if toolStop == nil {
-		t.Error("expected content_block_stop for tool_use block (index 1)")
-	}
-}
-
 func TestStreamConverter_ToolCallWithUnmarshalableArgs(t *testing.T) {
 	// Test that unmarshalable arguments (like channels) are handled gracefully
 	// and don't cause a panic or corrupt stream
@@ -1205,7 +864,7 @@ func TestStreamConverter_MultipleToolCallsWithMixedValidity(t *testing.T) {
 					ID: "call_good",
 					Function: api.ToolCallFunction{
 						Name:      "good_function",
-						Arguments: makeArgs("location", "Paris"),
+						Arguments: testArgs(map[string]any{"location": "Paris"}),
 					},
 				},
 				{
@@ -1307,57 +966,6 @@ func TestContentBlockJSON_EmptyFieldsPresent(t *testing.T) {
 	}
 }

-func TestContentBlockJSON_NonToolBlocksDoNotIncludeInput(t *testing.T) {
-	tests := []struct {
-		name  string
-		block ContentBlock
-	}{
-		{
-			name: "text block",
-			block: ContentBlock{
-				Type: "text",
-				Text: ptr("hello"),
-			},
-		},
-		{
-			name: "thinking block",
-			block: ContentBlock{
-				Type:     "thinking",
-				Thinking: ptr("let me think"),
-			},
-		},
-		{
-			name: "image block",
-			block: ContentBlock{
-				Type: "image",
-				Source: &ImageSource{
-					Type:      "base64",
-					MediaType: "image/png",
-					Data:      testImage,
-				},
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			data, err := json.Marshal(tt.block)
-			if err != nil {
-				t.Fatalf("failed to marshal: %v", err)
-			}
-
-			var result map[string]any
-			if err := json.Unmarshal(data, &result); err != nil {
-				t.Fatalf("failed to unmarshal: %v", err)
-			}
-
-			if _, ok := result["input"]; ok {
-				t.Fatalf("unexpected input field in non-tool block JSON: %s", string(data))
-			}
-		})
-	}
-}
-
 func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
 	t.Run("text block start includes empty text", func(t *testing.T) {
 		conv := NewStreamConverter("msg_123", "test-model", 0)
@@ -1378,9 +986,7 @@ func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
 						// Marshal and verify the text field is present
 						data, _ := json.Marshal(start)
 						var result map[string]any
-						if err := json.Unmarshal(data, &result); err != nil {
-							t.Fatalf("failed to unmarshal content_block_start JSON: %v", err)
-						}
+						json.Unmarshal(data, &result)
 						cb := result["content_block"].(map[string]any)
 						if _, ok := cb["text"]; !ok {
 							t.Error("content_block_start for text should include 'text' field")
@@ -1427,71 +1033,13 @@ func TestStreamConverter_ContentBlockStartIncludesEmptyFields(t *testing.T) {
 			t.Error("expected thinking content_block_start event")
 		}
 	})
-
-	t.Run("tool_use block start includes empty input object", func(t *testing.T) {
-		conv := NewStreamConverter("msg_123", "test-model", 0)
-
-		resp := api.ChatResponse{
-			Model: "test-model",
-			Message: api.Message{
-				Role: "assistant",
-				ToolCalls: []api.ToolCall{
-					{
-						ID: "call_123",
-						Function: api.ToolCallFunction{
-							Name:      "get_weather",
-							Arguments: makeArgs("location", "Paris"),
-						},
-					},
-				},
-			},
-		}
-
-		events := conv.Process(resp)
-
-		var foundToolStart bool
-		for _, e := range events {
-			if e.Event == "content_block_start" {
-				if start, ok := e.Data.(ContentBlockStartEvent); ok {
-					if start.ContentBlock.Type == "tool_use" {
-						foundToolStart = true
-						if start.ContentBlock.Input.Len() != 0 {
-							t.Errorf("expected empty input object, got len=%d", start.ContentBlock.Input.Len())
-						}
-
-						data, _ := json.Marshal(start)
-						var result map[string]any
-						json.Unmarshal(data, &result)
-						cb := result["content_block"].(map[string]any)
-						input, ok := cb["input"]
-						if !ok {
-							t.Error("content_block_start for tool_use should include 'input' field")
-							continue
-						}
-						inputMap, ok := input.(map[string]any)
-						if !ok {
-							t.Errorf("input field should be an object, got %T", input)
-							continue
-						}
-						if len(inputMap) != 0 {
-							t.Errorf("expected empty input object in content_block_start, got %v", inputMap)
-						}
-					}
-				}
-			}
-		}
-
-		if !foundToolStart {
-			t.Error("expected tool_use content_block_start event")
-		}
-	})
 }

 func TestEstimateTokens_SimpleMessage(t *testing.T) {
 	req := CountTokensRequest{
 		Model: "test-model",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello, world!")},
+			{Role: "user", Content: "Hello, world!"},
 		},
 	}

@@ -1512,7 +1060,7 @@ func TestEstimateTokens_WithSystemPrompt(t *testing.T) {
 		Model:  "test-model",
 		System: "You are a helpful assistant.",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 		},
 	}

@@ -1528,7 +1076,7 @@ func TestEstimateTokens_WithTools(t *testing.T) {
 	req := CountTokensRequest{
 		Model: "test-model",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("What's the weather?")},
+			{Role: "user", Content: "What's the weather?"},
 		},
 		Tools: []Tool{
 			{
@@ -1551,17 +1099,17 @@ func TestEstimateTokens_WithThinking(t *testing.T) {
 	req := CountTokensRequest{
 		Model: "test-model",
 		Messages: []MessageParam{
-			{Role: "user", Content: textContent("Hello")},
+			{Role: "user", Content: "Hello"},
 			{
 				Role: "assistant",
-				Content: []ContentBlock{
-					{
-						Type:     "thinking",
-						Thinking: ptr("Let me think about this carefully..."),
+				Content: []any{
+					map[string]any{
+						"type":     "thinking",
+						"thinking": "Let me think about this carefully...",
 					},
-					{
-						Type: "text",
-						Text: ptr("Here is my response."),
+					map[string]any{
+						"type": "text",
+						"text": "Here is my response.",
 					},
 				},
 			},
@@ -1659,12 +1207,12 @@ func TestConvertTool_RegularTool(t *testing.T) {
 func TestConvertMessage_ServerToolUse(t *testing.T) {
 	msg := MessageParam{
 		Role: "assistant",
-		Content: []ContentBlock{
-			{
-				Type:  "server_tool_use",
-				ID:    "srvtoolu_123",
-				Name:  "web_search",
-				Input: makeArgs("query", "test query"),
+		Content: []any{
+			map[string]any{
+				"type":  "server_tool_use",
+				"id":    "srvtoolu_123",
+				"name":  "web_search",
+				"input": map[string]any{"query": "test query"},
 			},
 		},
 	}
@@ -1695,11 +1243,11 @@ func TestConvertMessage_ServerToolUse(t *testing.T) {
 func TestConvertMessage_WebSearchToolResult(t *testing.T) {
 	msg := MessageParam{
 		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_123",
-				Content: []any{
+		Content: []any{
+			map[string]any{
+				"type":        "web_search_tool_result",
+				"tool_use_id": "srvtoolu_123",
+				"content": []any{
 					map[string]any{
 						"type":  "web_search_result",
 						"title": "Test Result",
@@ -1736,11 +1284,11 @@ func TestConvertMessage_WebSearchToolResult(t *testing.T) {
 func TestConvertMessage_WebSearchToolResultEmptyStillCreatesToolMessage(t *testing.T) {
 	msg := MessageParam{
 		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_empty",
-				Content:   []any{},
+		Content: []any{
+			map[string]any{
+				"type":        "web_search_tool_result",
+				"tool_use_id": "srvtoolu_empty",
+				"content":     []any{},
 			},
 		},
 	}
@@ -1767,11 +1315,11 @@ func TestConvertMessage_WebSearchToolResultEmptyStillCreatesToolMessage(t *testi
 func TestConvertMessage_WebSearchToolResultErrorStillCreatesToolMessage(t *testing.T) {
 	msg := MessageParam{
 		Role: "user",
-		Content: []ContentBlock{
-			{
-				Type:      "web_search_tool_result",
-				ToolUseID: "srvtoolu_error",
-				Content: map[string]any{
+		Content: []any{
+			map[string]any{
+				"type":        "web_search_tool_result",
+				"tool_use_id": "srvtoolu_error",
+				"content": map[string]any{
 					"type":       "web_search_tool_result_error",
 					"error_code": "max_uses_exceeded",
 				},
@@ -368,16 +368,6 @@ func (c *Client) List(ctx context.Context) (*ListResponse, error) {
 	return &lr, nil
 }

-// ModelRecommendationsExperimental lists model recommendations from the local
-// server's experimental recommendations endpoint.
-func (c *Client) ModelRecommendationsExperimental(ctx context.Context) (*ModelRecommendationsResponse, error) {
-	var resp ModelRecommendationsResponse
-	if err := c.do(ctx, http.MethodGet, "/api/experimental/model-recommendations", nil, &resp); err != nil {
-		return nil, err
-	}
-	return &resp, nil
-}
-
 // ListRunning lists running models.
 func (c *Client) ListRunning(ctx context.Context) (*ProcessResponse, error) {
 	var lr ProcessResponse
@@ -486,3 +476,25 @@ func (c *Client) Whoami(ctx context.Context) (*UserResponse, error) {
 	}
 	return &resp, nil
 }
+
+// AliasRequest is the request body for creating or updating a model alias.
+type AliasRequest struct {
+	Alias          string `json:"alias"`
+	Target         string `json:"target"`
+	PrefixMatching bool   `json:"prefix_matching,omitempty"`
+}
+
+// SetAliasExperimental creates or updates a model alias via the experimental aliases API.
+func (c *Client) SetAliasExperimental(ctx context.Context, req *AliasRequest) error {
+	return c.do(ctx, http.MethodPost, "/api/experimental/aliases", req, nil)
+}
+
+// AliasDeleteRequest is the request body for deleting a model alias.
+type AliasDeleteRequest struct {
+	Alias string `json:"alias"`
+}
+
+// DeleteAliasExperimental deletes a model alias via the experimental aliases API.
+func (c *Client) DeleteAliasExperimental(ctx context.Context, req *AliasDeleteRequest) error {
+	return c.do(ctx, http.MethodDelete, "/api/experimental/aliases", req, nil)
+}
@@ -436,7 +436,6 @@ type ToolProperty struct {
 	Description string             `json:"description,omitempty"`
 	Enum        []any              `json:"enum,omitempty"`
 	Properties  *ToolPropertiesMap `json:"properties,omitempty"`
-	Required    []string           `json:"required,omitempty"`
 }

 // ToTypeScriptType converts a ToolProperty to a TypeScript type string
@@ -802,21 +801,6 @@ type ListResponse struct {
 	Models []ListModelResponse `json:"models"`
 }

-// ModelRecommendationsResponse is the response from [Client.ModelRecommendationsExperimental].
-type ModelRecommendationsResponse struct {
-	Recommendations []ModelRecommendation `json:"recommendations"`
-}
-
-// ModelRecommendation is a single recommendation entry in [ModelRecommendationsResponse].
-type ModelRecommendation struct {
-	Model           string `json:"model"`
-	Description     string `json:"description"`
-	ContextLength   int    `json:"context_length,omitempty"`
-	MaxOutputTokens int    `json:"max_output_tokens,omitempty"`
-	VRAMBytes       int64  `json:"vram_bytes,omitempty"`
-	RequiredPlan    string `json:"required_plan,omitempty"`
-}
-
 // ProcessResponse is the response from [Client.Process].
 type ProcessResponse struct {
 	Models []ProcessModelResponse `json:"models"`
@@ -824,15 +808,14 @@ type ProcessResponse struct {

 // ListModelResponse is a single model description in [ListResponse].
 type ListModelResponse struct {
-	Name         string             `json:"name"`
-	Model        string             `json:"model"`
-	RemoteModel  string             `json:"remote_model,omitempty"`
-	RemoteHost   string             `json:"remote_host,omitempty"`
-	ModifiedAt   time.Time          `json:"modified_at"`
-	Size         int64              `json:"size"`
-	Digest       string             `json:"digest"`
-	Details      ModelDetails       `json:"details,omitempty"`
-	Capabilities []model.Capability `json:"capabilities,omitempty"`
+	Name        string       `json:"name"`
+	Model       string       `json:"model"`
+	RemoteModel string       `json:"remote_model,omitempty"`
+	RemoteHost  string       `json:"remote_host,omitempty"`
+	ModifiedAt  time.Time    `json:"modified_at"`
+	Size        int64        `json:"size"`
+	Digest      string       `json:"digest"`
+	Details     ModelDetails `json:"details,omitempty"`
 }

 // ProcessModelResponse is a single model description in [ProcessResponse].
@@ -925,8 +908,6 @@ type ModelDetails struct {
 	Families          []string `json:"families"`
 	ParameterSize     string   `json:"parameter_size"`
 	QuantizationLevel string   `json:"quantization_level"`
-	ContextLength     int      `json:"context_length,omitempty"`
-	EmbeddingLength   int      `json:"embedding_length,omitempty"`
 }

 // UserResponse provides information about a user.
@@ -1098,7 +1079,7 @@ func DefaultOptions() Options {
 	}
 }

-// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low", "max")
+// ThinkValue represents a value that can be a boolean or a string ("high", "medium", "low")
 type ThinkValue struct {
 	// Value can be a bool or string
 	Value interface{}
@@ -1114,7 +1095,7 @@ func (t *ThinkValue) IsValid() bool {
 	case bool:
 		return true
 	case string:
-		return v == "high" || v == "medium" || v == "low" || v == "max"
+		return v == "high" || v == "medium" || v == "low"
 	default:
 		return false
 	}
@@ -1148,8 +1129,8 @@ func (t *ThinkValue) Bool() bool {
 	case bool:
 		return v
 	case string:
-		// Any string value ("high", "medium", "low", "max") means thinking is enabled
-		return v == "high" || v == "medium" || v == "low" || v == "max"
+		// Any string value ("high", "medium", "low") means thinking is enabled
+		return v == "high" || v == "medium" || v == "low"
 	default:
 		return false
 	}
@@ -1187,14 +1168,14 @@ func (t *ThinkValue) UnmarshalJSON(data []byte) error {
 	var s string
 	if err := json.Unmarshal(data, &s); err == nil {
 		// Validate string values
-		if s != "high" && s != "medium" && s != "low" && s != "max" {
-			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", \"max\", true, or false)", s)
+		if s != "high" && s != "medium" && s != "low" {
+			return fmt.Errorf("invalid think value: %q (must be \"high\", \"medium\", \"low\", true, or false)", s)
 		}
 		t.Value = s
 		return nil
 	}

-	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", \"max\", true, or false)")
+	return fmt.Errorf("think must be a boolean or string (\"high\", \"medium\", \"low\", true, or false)")
 }

 // MarshalJSON implements json.Marshaler
@@ -495,11 +495,6 @@ func TestThinking_UnmarshalJSON(t *testing.T) {
 			input:            `{ "think": "low" }`,
 			expectedThinking: &ThinkValue{Value: "low"},
 		},
-		{
-			name:             "string_max",
-			input:            `{ "think": "max" }`,
-			expectedThinking: &ThinkValue{Value: "max"},
-		},
 		{
 			name:             "invalid_string",
 			input:            `{ "think": "invalid" }`,
@@ -157,6 +157,10 @@ func main() {
 		}
 	}

+	if u := os.Getenv("OLLAMA_UPDATE_URL"); u != "" {
+		updater.UpdateCheckURLBase = u
+	}
+
 	// Detect if this is a first start after an upgrade, in
 	// which case we need to do some cleanup
 	var skipMove bool
@@ -83,29 +83,6 @@ func resolvePath(name string) string {
 	return name
 }

-func ollamaServeArgs(args []string) bool {
-	if len(args) < 2 {
-		return false
-	}
-
-	switch strings.Trim(filepath.Base(args[0]), `"`) {
-	case "ollama", "ollama.exe":
-	default:
-		return false
-	}
-
-	for _, rawArg := range args[1:] {
-		arg := strings.Trim(rawArg, `"`)
-		if strings.HasPrefix(arg, "-") {
-			continue
-		}
-
-		return arg == "serve" || arg == "start"
-	}
-
-	return false
-}
-
 // cleanup checks the pid file for a running ollama process
 // and shuts it down gracefully if it is running
 func cleanup() error {
@@ -205,63 +205,6 @@ func TestServerCmdCloudSettingEnv(t *testing.T) {
 	}
 }

-func TestOllamaServeArgs(t *testing.T) {
-	tests := []struct {
-		name string
-		args []string
-		want bool
-	}{
-		{
-			name: "system ollama serve",
-			args: []string{"ollama", "serve"},
-			want: true,
-		},
-		{
-			name: "relative path ollama serve",
-			args: []string{"./ollama", "serve"},
-			want: true,
-		},
-		{
-			name: "serve after other flags",
-			args: []string{"./ollama", "--verbose", "serve"},
-			want: true,
-		},
-		{
-			name: "start alias",
-			args: []string{"ollama", "start"},
-			want: true,
-		},
-		{
-			name: "launch command",
-			args: []string{"ollama", "launch", "opencode"},
-			want: false,
-		},
-		{
-			name: "run command with model named serve",
-			args: []string{"ollama", "run", "serve"},
-			want: false,
-		},
-		{
-			name: "launch command with serve in passthrough args",
-			args: []string{"ollama", "launch", "codex", "--", "-p", "serve"},
-			want: false,
-		},
-		{
-			name: "different executable",
-			args: []string{"go", "run", "serve"},
-			want: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := ollamaServeArgs(tt.args); got != tt.want {
-				t.Fatalf("ollamaServeArgs(%v) = %v, want %v", tt.args, got, tt.want)
-			}
-		})
-	}
-}
-
 func TestGetInferenceInfo(t *testing.T) {
 	tests := []struct {
 		name             string
@@ -46,17 +46,7 @@ func terminated(pid int) (bool, error) {
 	return false, nil
 }

-func ollamaServeProcess(pid int) bool {
-	output, err := exec.Command("ps", "-p", strconv.Itoa(pid), "-o", "args=").Output()
-	if err != nil {
-		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
-		return false
-	}
-
-	return ollamaServeArgs(strings.Fields(strings.TrimSpace(string(output))))
-}
-
-// reapServers kills external ollama serve processes except our own.
+// reapServers kills all ollama processes except our own
 func reapServers() error {
 	// Get our own PID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -92,9 +82,6 @@ func reapServers() error {
 		if pid == currentPID {
 			continue
 		}
-		if !ollamaServeProcess(pid) {
-			continue
-		}

 		proc, err := os.FindProcess(pid)
 		if err != nil {
@@ -101,29 +101,7 @@ func terminated(pid int) (bool, error) {
 	return true, nil
 }

-func ollamaServeProcess(pid int) bool {
-	cmd := exec.Command("wmic", "process", "where", fmt.Sprintf("ProcessId=%d", pid), "get", "CommandLine", "/value")
-	cmd.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}
-	output, err := cmd.Output()
-	if err != nil {
-		slog.Debug("failed to inspect ollama process", "pid", pid, "err", err)
-		return false
-	}
-
-	for _, line := range strings.Split(string(output), "\n") {
-		line = strings.TrimSpace(line)
-		commandLine, ok := strings.CutPrefix(line, "CommandLine=")
-		if !ok {
-			continue
-		}
-
-		return ollamaServeArgs(strings.Fields(strings.ToLower(commandLine)))
-	}
-
-	return false
-}
-
-// reapServers kills external ollama serve processes except our own.
+// reapServers kills all ollama processes except our own
 func reapServers() error {
 	// Get current process ID to avoid killing ourselves
 	currentPID := os.Getpid()
@@ -160,9 +138,6 @@ func reapServers() error {
 		if pid == currentPID {
 			continue
 		}
-		if !ollamaServeProcess(pid) {
-			continue
-		}

 		cmd := exec.Command("taskkill", "/F", "/PID", pidStr)
 		if err := cmd.Run(); err != nil {
@@ -14,7 +14,7 @@ import (

 // currentSchemaVersion defines the current database schema version.
 // Increment this when making schema changes that require migrations.
-const currentSchemaVersion = 16
+const currentSchemaVersion = 15

 // database wraps the SQLite connection.
 // SQLite handles its own locking for concurrent access:
@@ -82,7 +82,6 @@ func (db *database) init() error {
 		websearch_enabled BOOLEAN NOT NULL DEFAULT 0,
 		selected_model TEXT NOT NULL DEFAULT '',
 		sidebar_open BOOLEAN NOT NULL DEFAULT 0,
-		last_home_view TEXT NOT NULL DEFAULT 'launch',
 		think_enabled BOOLEAN NOT NULL DEFAULT 0,
 		think_level TEXT NOT NULL DEFAULT '',
 		cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0,
@@ -265,12 +264,6 @@ func (db *database) migrate() error {
 				return fmt.Errorf("migrate v14 to v15: %w", err)
 			}
 			version = 15
-		case 15:
-			// add last_home_view column to settings table
-			if err := db.migrateV15ToV16(); err != nil {
-				return fmt.Errorf("migrate v15 to v16: %w", err)
-			}
-			version = 16
 		default:
 			// If we have a version we don't recognize, just set it to current
 			// This might happen during development
@@ -525,21 +518,6 @@ func (db *database) migrateV14ToV15() error {
 	return nil
 }

-// migrateV15ToV16 adds the last_home_view column to the settings table
-func (db *database) migrateV15ToV16() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN last_home_view TEXT NOT NULL DEFAULT 'launch'`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add last_home_view column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 16`)
-	if err != nil {
-		return fmt.Errorf("update schema version: %w", err)
-	}
-
-	return nil
-}
-
 // cleanupOrphanedData removes orphaned records that may exist due to the foreign key bug
 func (db *database) cleanupOrphanedData() error {
 	_, err := db.conn.Exec(`
@@ -1188,9 +1166,9 @@ func (db *database) getSettings() (Settings, error) {
 	var s Settings

 	err := db.conn.QueryRow(`
-		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, last_home_view, think_enabled, think_level, auto_update_enabled
+		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, turbo_enabled, websearch_enabled, selected_model, sidebar_open, think_enabled, think_level, auto_update_enabled
 		FROM settings
-	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.LastHomeView, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled)
+	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.ThinkEnabled, &s.ThinkLevel, &s.AutoUpdateEnabled)
 	if err != nil {
 		return Settings{}, fmt.Errorf("get settings: %w", err)
 	}
@@ -1199,29 +1177,10 @@ func (db *database) getSettings() (Settings, error) {
 }

 func (db *database) setSettings(s Settings) error {
-	lastHomeView := strings.ToLower(strings.TrimSpace(s.LastHomeView))
-	validLaunchView := map[string]struct{}{
-		"launch":    {},
-		"openclaw":  {},
-		"claude":    {},
-		"hermes":    {},
-		"codex":     {},
-		"codex-app": {},
-		"copilot":   {},
-		"opencode":  {},
-		"droid":     {},
-		"pi":        {},
-	}
-	if lastHomeView != "chat" {
-		if _, ok := validLaunchView[lastHomeView]; !ok {
-			lastHomeView = "launch"
-		}
-	}
-
 	_, err := db.conn.Exec(`
 		UPDATE settings
-		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, last_home_view = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?
-	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, lastHomeView, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled)
+		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, think_enabled = ?, think_level = ?, auto_update_enabled = ?
+	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, s.ThinkEnabled, s.ThinkLevel, s.AutoUpdateEnabled)
 	if err != nil {
 		return fmt.Errorf("set settings: %w", err)
 	}
@@ -135,45 +135,6 @@ func TestMigrationV13ToV14ContextLength(t *testing.T) {
 	}
 }

-func TestMigrationV15ToV16LastHomeViewDefaultsToLaunch(t *testing.T) {
-	tmpDir := t.TempDir()
-	dbPath := filepath.Join(tmpDir, "test.db")
-
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-	defer db.Close()
-
-	if _, err := db.conn.Exec(`
-		ALTER TABLE settings DROP COLUMN last_home_view;
-		UPDATE settings SET schema_version = 15;
-	`); err != nil {
-		t.Fatalf("failed to seed v15 settings row: %v", err)
-	}
-
-	if err := db.migrate(); err != nil {
-		t.Fatalf("migration from v15 to v16 failed: %v", err)
-	}
-
-	var lastHomeView string
-	if err := db.conn.QueryRow("SELECT last_home_view FROM settings").Scan(&lastHomeView); err != nil {
-		t.Fatalf("failed to read last_home_view: %v", err)
-	}
-
-	if lastHomeView != "launch" {
-		t.Fatalf("expected last_home_view to default to launch after migration, got %q", lastHomeView)
-	}
-
-	version, err := db.getSchemaVersion()
-	if err != nil {
-		t.Fatalf("failed to get schema version: %v", err)
-	}
-	if version != currentSchemaVersion {
-		t.Fatalf("expected schema version %d, got %d", currentSchemaVersion, version)
-	}
-}
-
 func TestChatDeletionWithCascade(t *testing.T) {
 	t.Run("chat deletion cascades to related messages", func(t *testing.T) {
 		tmpDir := t.TempDir()
@@ -167,9 +167,6 @@ type Settings struct {
 	// SidebarOpen indicates if the chat sidebar is open
 	SidebarOpen bool

-	// LastHomeView stores the preferred home route target ("chat" or integration name)
-	LastHomeView string
-
 	// AutoUpdateEnabled indicates if automatic updates should be downloaded
 	AutoUpdateEnabled bool
 }
@@ -392,10 +389,6 @@ func (s *Store) Settings() (Settings, error) {
 		}
 	}

-	if settings.LastHomeView == "" {
-		settings.LastHomeView = "launch"
-	}
-
 	return settings, nil
 }

@@ -81,62 +81,6 @@ func TestStore(t *testing.T) {
 		}
 	})

-	t.Run("settings default home view is launch", func(t *testing.T) {
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "launch" {
-			t.Fatalf("expected default LastHomeView to be launch, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings empty home view falls back to launch", func(t *testing.T) {
-		if err := s.SetSettings(Settings{LastHomeView: ""}); err != nil {
-			t.Fatal(err)
-		}
-
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "launch" {
-			t.Fatalf("expected empty LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings disabled home view falls back to launch", func(t *testing.T) {
-		if err := s.SetSettings(Settings{LastHomeView: "claude-desktop"}); err != nil {
-			t.Fatal(err)
-		}
-
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "launch" {
-			t.Fatalf("expected disabled LastHomeView to fall back to launch, got %q", loaded.LastHomeView)
-		}
-	})
-
-	t.Run("settings codex app home view is accepted", func(t *testing.T) {
-		if err := s.SetSettings(Settings{LastHomeView: "codex-app"}); err != nil {
-			t.Fatal(err)
-		}
-
-		loaded, err := s.Settings()
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		if loaded.LastHomeView != "codex-app" {
-			t.Fatalf("expected codex-app LastHomeView to be preserved, got %q", loaded.LastHomeView)
-		}
-	})
-
 	t.Run("window size", func(t *testing.T) {
 		if err := s.SetWindowSize(1024, 768); err != nil {
 			t.Fatal(err)
@@ -414,7 +414,6 @@ export class Settings {
    ThinkLevel: string;
    SelectedModel: string;
    SidebarOpen: boolean;
-    LastHomeView: string;
    AutoUpdateEnabled: boolean;

    constructor(source: any = {}) {
@@ -433,7 +432,6 @@ export class Settings {
        this.ThinkLevel = source["ThinkLevel"];
        this.SelectedModel = source["SelectedModel"];
        this.SidebarOpen = source["SidebarOpen"];
-        this.LastHomeView = source["LastHomeView"];
        this.AutoUpdateEnabled = source["AutoUpdateEnabled"];
    }
 }
@@ -552,12 +550,14 @@ export class Error {
    }
 }
 export class ModelUpstreamResponse {
-    stale: boolean;
+    digest?: string;
+    pushTime: number;
    error?: string;

    constructor(source: any = {}) {
        if ('string' === typeof source) source = JSON.parse(source);
-        this.stale = source["stale"];
+        this.digest = source["digest"];
+        this.pushTime = source["pushTime"];
        this.error = source["error"];
    }
 }
@@ -1 +0,0 @@
-<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated by Pixelmator Pro 3.6.17 -->
-<svg width="1200" height="1200" viewBox="0 0 1200 1200" xmlns="http://www.w3.org/2000/svg">
-    <g id="g314">
-        <path id="path147" fill="#d97757" stroke="none" d="M 233.959793 800.214905 L 468.644287 668.536987 L 472.590637 657.100647 L 468.644287 650.738403 L 457.208069 650.738403 L 417.986633 648.322144 L 283.892639 644.69812 L 167.597321 639.865845 L 54.926208 633.825623 L 26.577238 627.785339 L 3.3e-05 592.751709 L 2.73832 575.27533 L 26.577238 559.248352 L 60.724873 562.228149 L 136.187973 567.382629 L 249.422867 575.194763 L 331.570496 580.026978 L 453.261841 592.671082 L 472.590637 592.671082 L 475.328857 584.859009 L 468.724915 580.026978 L 463.570557 575.194763 L 346.389313 495.785217 L 219.543671 411.865906 L 153.100723 363.543762 L 117.181267 339.060425 L 99.060455 316.107361 L 91.248367 266.01355 L 123.865784 230.093994 L 167.677887 233.073853 L 178.872513 236.053772 L 223.248367 270.201477 L 318.040283 343.570496 L 441.825592 434.738342 L 459.946411 449.798706 L 467.194672 444.64447 L 468.080597 441.020203 L 459.946411 427.409485 L 392.617493 305.718323 L 320.778564 181.932983 L 288.80542 130.630859 L 280.348999 99.865845 C 277.369171 87.221436 275.194641 76.590698 275.194641 63.624268 L 312.322174 13.20813 L 332.8591 6.604126 L 382.389313 13.20813 L 403.248352 31.328979 L 434.013519 101.71814 L 483.865753 212.537048 L 561.181274 363.221497 L 583.812134 407.919434 L 595.892639 449.315491 L 600.40271 461.959839 L 608.214783 461.959839 L 608.214783 454.711609 L 614.577271 369.825623 L 626.335632 265.61084 L 637.771851 131.516846 L 641.718201 93.745117 L 660.402832 48.483276 L 697.530334 24.000122 L 726.52356 37.852417 L 750.362549 72 L 747.060486 94.067139 L 732.886047 186.201416 L 705.100708 330.52356 L 686.979919 427.167847 L 697.530334 427.167847 L 709.61084 415.087341 L 758.496704 350.174561 L 840.644348 247.490051 L 876.885925 206.738342 L 919.167847 161.71814 L 946.308838 140.29541 L 997.61084 140.29541 L 1035.38269 196.429626 L 1018.469849 254.416199 L 965.637634 321.422852 L 921.825562 378.201538 L 859.006714 462.765259 L 819.785278 530.41626 L 823.409424 535.812073 L 832.75177 534.92627 L 974.657776 504.724915 L 1051.328979 490.872559 L 1142.818848 475.167786 L 1184.214844 494.496582 L 1188.724854 514.147644 L 1172.456421 554.335693 L 1074.604126 578.496765 L 959.838989 601.449829 L 788.939636 641.879272 L 786.845764 643.409485 L 789.261841 646.389343 L 866.255127 653.637634 L 899.194702 655.409424 L 979.812134 655.409424 L 1129.932861 666.604187 L 1169.154419 692.537109 L 1192.671265 724.268677 L 1188.724854 748.429688 L 1128.322144 779.194641 L 1046.818848 759.865845 L 856.590759 714.604126 L 791.355774 698.335754 L 782.335693 698.335754 L 782.335693 703.731567 L 836.69812 756.885986 L 936.322205 846.845581 L 1061.073975 962.81897 L 1067.436279 991.490112 L 1051.409424 1014.120911 L 1034.496704 1011.704712 L 924.885986 929.234924 L 882.604126 892.107544 L 786.845764 811.48999 L 780.483276 811.48999 L 780.483276 819.946289 L 802.550415 852.241699 L 919.087341 1027.409424 L 925.127625 1081.127686 L 916.671204 1098.604126 L 886.469849 1109.154419 L 853.288696 1103.114136 L 785.073914 1007.355835 L 714.684631 899.516785 L 657.906067 802.872498 L 650.979858 806.81897 L 617.476624 1167.704834 L 601.771851 1186.147705 L 565.530212 1200 L 535.328857 1177.046997 L 519.302124 1139.919556 L 535.328857 1066.550537 L 554.657776 970.792053 L 570.362488 894.68457 L 584.536926 800.134277 L 592.993347 768.724976 L 592.429626 766.630859 L 585.503479 767.516968 L 514.22821 865.369263 L 405.825531 1011.865906 L 320.053711 1103.677979 L 299.516815 1111.812256 L 263.919525 1093.369263 L 267.221497 1060.429688 L 287.114136 1031.114136 L 405.825531 880.107361 L 477.422913 786.52356 L 523.651062 732.483276 L 523.328918 724.671265 L 520.590698 724.671265 L 205.288605 929.395935 L 149.154434 936.644409 L 124.993355 914.01355 L 127.973183 876.885986 L 139.409409 864.80542 L 234.201385 799.570435 L 233.879227 799.8927 Z"/>
-    </g>
-</svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z" fill="white"/></svg>
@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" fill="currentColor" fill-rule="evenodd" style="flex:none;line-height:1" viewBox="0 2.5 24 19"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z"/></svg>
@@ -1,181 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="1000" height="1000" viewBox="0 0 1000 1000"><circle cx="500.0" cy="500.0" r="500.0" fill="white"/><g transform="translate(100.0 100.0) scale(0.8333333333333334)"><g transform="translate(0.000000,960.000000) scale(0.100000,-0.100000)"
-fill="black" stroke="none">
-<path d="M4485 9589 c-248 -27 -432 -60 -730 -130 -458 -108 -798 -230 -1207
-435 -533 -267 -1072 -675 -1358 -1030 -205 -255 -442 -748 -535 -1114 -108
-426 -97 -870 29 -1160 73 -169 236 -369 381 -467 139 -94 425 -206 425 -167
-0 3 -26 32 -58 63 -74 71 -147 182 -184 278 -16 41 -27 77 -25 79 2 3 31 -28
-63 -68 91 -114 153 -177 231 -235 40 -29 77 -62 83 -73 7 -13 4 -85 -10 -242
-10 -123 -24 -281 -30 -353 -6 -71 -29 -296 -51 -500 -135 -1262 -202 -1568
-378 -1733 -69 -64 -105 -77 -216 -77 -132 0 -188 20 -271 97 -110 103 -165
-248 -167 438 -1 123 12 191 60 318 20 51 33 95 29 99 -10 10 -92 -74 -136
-137 -153 -223 -204 -504 -146 -790 19 -91 97 -252 161 -333 112 -141 316
-237 504 -237 180 0 419 118 591 290 81 81 107 115 196 255 50 78 54 56 13
-71 -107 -337 -343 -577 -613 -625 -213 -39 -544 99 -707 295 -93 111 -133
-199 -173 381 -34 153 -34 154 -46 135 -15 -23 -12 -194 5 -305 42 -280 149
-488 327 -636 133 -111 287 -195 465 -254 62 -20 115 -40 117 -44 3 -4 12 -43
-21 -87 44 -222 199 -385 416 -438 96 -24 265 -21 359 5 138 38 281 148 388
-297 39 55 48 63 50 45 4 -27 -38 -185 -78 -294 -80 -217 -176 -374 -312 -515
-54 -55 -98 -104 -98 -107 0 -4 245 -7 545 -7 l544 0 126 66 c69 36 130 64
-135 62 6 -2 -10 -28 -34 -59 -46 -59 -48 -69 -10 -69 17 0 32 15 58 59 36 59
-51 71 87 71 23 0 25 -27 4 -77 -8 -19 -15 -39 -15 -44 0 -12 447 -11 470 1 10
-5 85 87 168 182 257 297 400 415 317 263 -16 -30 -26 -57 -23 -60 11 -12 210
-100 383 215 115 76 226 143 375 225 58 32 178 100 266 151 150 87 244 132 244
-117 0 -4 -78 -86 -174 -182 -207 -208 -246 -254 -334 -386 -48 -71 -122 -157
-259 -298 -117 -120 -193 -206 -193 -217 0 -19 8 -20 115 -20 101 0 116 2 122
-18 19 54 112 249 156 327 124 221 283 436 369 502 87 67 225 152 337 209 103
-51 297 117 384 130 38 6 29 -2 -92 -75 -74 -45 -170 -107 -214 -139 -106 -76
-247 -225 -332 -351 -67 -99 -70 -102 -79 -77 -6 14 -13 26 -18 26 -11 0 -57
-75 -94 -155 -63 -136 -124 -376 -103 -401 15 -18 152 -19 166 -2 6 7 18 36
-27 63 23 72 66 131 217 301 302 339 430 464 590 577 148 104 233 128 520 148
-205 14 255 9 447 -38 118 -29 183 -65 298 -163 229 -195 538 -577 579 -715 24
-83 71 -117 109 -79 9 8 16 27 16 42 0 62 -40 212 -73 277 -158 313 -551 635
-922 755 -127 41 -142 55 -52 46 117 -11 231 -35 321 -65 158 -54 259 -123
-405 -277 164 -174 283 -379 322 -556 11 -51 25 -113 32 -137 36 -128 148 -81
-117 49 -14 60 -7 106 27 177 36 74 62 94 224 179 254 133 425 260 561 417 272
-315 403 732 358 1138 -24 218 -84 401 -179 545 -65 98 -155 203 -166 192 -3
-3 7 -37 23 -75 136 -309 136 -725 2 -1063 -130 -330 -441 -760 -633 -879 -60
-37 -60 -20 2 54 478 577 578 1337 315 2390 -25 99 -86 326 -136 505 -169 611
-386 1539 -494 2109 -161 857 -200 998 -442 1606 -161 405 -321 692 -529 950
-93 114 -322 343 -433 431 -203 160 -497 332 -737 428 -293 118 -702 220 -978
-246 -129 12 -406 11 -520 -1z m-267 -214 c301 -47 596 -191 852 -419 85 -76
-266 -270 345 -371 294 -376 520 -873 640 -1409 45 -199 45 -222 3 -244 -18 -9
-45 -30 -61 -45 -25 -23 -28 -33 -23 -60 9 -44 21 -54 121 -98 91 -40 225
-124 225 -140 0 -9 -33 5 -211 89 -126 60 -159 94 -167 173 -5 50 14 89 43 89
-26 0 65 49 65 81 0 52 -22 110 -48 127 -23 15 -37 14 -186 -7 -172 -25 -210
-36 -240 -69 -23 -27 -31 -99 -14 -131 16 -29 30 -37 85 -51 26 -7 44 -17 48
-29 10 -32 -15 -153 -41 -197 -27 -49 -131 -161 -139 -152 -9 9 36 77 85 126
-23 24 48 60 56 79 13 31 13 38 -3 71 -10 20 -29 42 -43 48 -14 7 -37 18 -52
-24 -33 15 -42 39 -63 155 -24 133 -90 393 -135 532 -119 367 -287 686 -483
-919 -175 208 -434 427 -659 557 -229 131 -498 197 -804 197 -136 0 -185 -4
-313 -26 -87 -14 -31 14 137 70 186 61 289 89 437 117 120 23 376 20 543 -6z
-m2913 -962 c50 -53 113 -138 198 -268 76 -116 60 -104 -41 32 -34 46 -63 81
-66 79 -2 -2 2 -30 9 -63 9 -44 9 -86 1 -171 -6 -63 -13 -116 -16 -119 -3 -4
-15 2 -26 12 -32 29 -34 12 -5 -57 50 -118 66 -160 62 -164 -2 -2 -29 34 -61
-81 -31 47 -61 83 -66 80 -6 -4 -7 -24 -4 -47 7 -39 6 -40 -14 -27 -12 7 -25
-10 -29 5 -17 -17 -4 -106 31 -210 20 -60 35 -111 33 -112 -2 -2 -30 43 -62 99
-60 102 -173 233 -182 210 -2 -7 26 -82 62 -168 37 -85 65 -160 63 -166 -2 -6
-43 66 -91 160 -63 121 -93 171 -106 171 -9 0 -37 -21 -61 -46 -55 -56 -56
-56 -248 20 -78 31 -156 59 -172 63 l-30 6 24 -54 c13 -30 51 -114 85 -188 34
-73 60 -135 58 -137 -2 -3 -21 24 -42 58 -56 91 -85 128 -102 128 -13 0 -14
-8 -9 -42 l7 -42 -83 80 c-109 106 -163 133 -260 126 -35 -3 -38 0 -53 34 -9
-21 -13 44 -11 51 7 17 58 16 147 -2 101 -21 104 -17 92 106 -6 52 -7 98 -3
-102 4 5 25 -20 47 -55 22 -35 47 -68 54 -75 18 -14 278 -83 316 -83 23 0 42
-13 86 59 61 64 64 72 42 111 -19 33 -19 54 0 46 11 -4 23 6 37 30 l21 35 66
-3 66 -3 -2 29 c-1 16 -25 63 -52 105 -28 41 -49 77 -47 78 2 2 47 -42 101
-97 75 -76 105 -100 125 -100 14 0 35 -7 47 -15 20 -14 22 -14 27 2 3 10 6 72
-7 138 2 102 -1 128 -19 175 -12 30 -22 56 -22 58 0 9 40 -22 71 -55z m-2642
-139 c29 -35 60 -64 67 -64 8 0 52 27 97 61 l82 60 47 -51 c59 -63 161 -218
-218 -327 23 -46 48 -83 55 -83 8 0 26 5 41 11 49 18 73 4 104 -64 33 -70 48
-127 33 -127 -6 0 -32 9 -58 21 -28 12 -56 18 -71 15 -21 -6 -27 1 -55 56 -67
-132 -208 340 -244 361 -10 5 -19 -1 -29 -22 -29 -55 -35 -106 -20 -183 8 -40
-14 -74 14 -75 0 -1 -12 2 -26 8 l-27 10 7 -62 c6 -61 6 -62 -14 -44 -15 14
-31 17 -72 13 -58 -6 -88 -32 -88 -76 l0 -26 -29 34 c-29 35 -30 35 -122 38
-52 2 -99 8 -106 14 -15 12 -83 132 -83 146 0 6 23 39 50 73 56 70 68 99 52
-134 -12 27 -15 25 81 46 65 14 68 21 42 105 -26 85 -18 85 54 -2z m-397 -294
-c84 -126 196 -352 237 -475 33 -99 28 -115 -23 -66 -45 44 -55 29 -49 -77 5
-95 -4 -97 -33 -7 -22 67 -52 125 -64 125 -6 0 -10 -39 -11 -92 0 -51 -4 -101
-8 -111 -9 -23 -10 -22 -85 101 -32 50 -62 92 -68 92 -7 0 -9 -22 -4 -70 6
-74 -3 -90 -24 -40 -21 50 -33 54 -87 30 -26 -11 -57 -30 -69 -41 -20 -19 -21
-19 -75 10 -30 17 -91 41 -137 54 -46 13 -89 30 -97 38 -16 16 -45 142 -36
-157 3 5 58 33 121 61 l114 51 21 -26 21 -26 49 39 c51 40 69 66 80 116 5 23
-10 28 32 25 19 -2 28 -11 37 -38 37 -115 42 114 6 250 -45 171 -47 164 22 90
-33 -36 92 -112 130 -170z m-1789 73 c-3 -10 -32 -77 -63 -148 -48 -109 -137
-340 -242 -628 -11 -32 -22 -56 -24 -54 -2 2 -9 32 -14 68 -24 141 -20 131
-47 124 -13 -3 -50 -18 -81 -33 -43 -20 -62 -37 -79 -67 -32 -59 -40 -65 -88
-65 -55 0 -56 6 -16 106 29 75 176 339 194 351 12 7 14 14 -47 -125 -25 -56
-46 -113 -46 -127 0 -25 0 -25 35 -11 109 46 179 120 301 316 135 217 241 360
-217 293z m-869 -35 c-4 -7 -33 -49 -64 -93 -140 -200 -268 -431 -368 -665
-114 -268 -153 -314 -74 -86 41 115 44 129 29 137 -28 16 -39 80 -22 128 27
-77 98 202 139 246 58 61 355 345 362 345 3 0 2 -6 -2 -12z m1415 -533 l1 -130
-23 39 c-26 47 -41 51 -45 14 -4 -36 -18 -35 -37 1 -8 17 -19 32 -25 36 -5 3
-60 -10 -122 -30 -76 -25 -130 -36 -165 -36 -29 1 -82 -5 -118 -14 -99 -23
-109 -21 -149 29 -20 23 -36 50 -36 58 0 12 55 182 75 231 11 27 38 21 147
-34 76 -38 108 -49 130 -45 21 4 28 2 28 -9 0 -10 11 -15 34 -15 45 0 153 34
-177 56 10 9 35 69 55 133 56 180 58 180 65 1 4 -85 7 -213 8 -285z m-1394 272
-c-31 -55 -32 -83 -2 -91 47 -12 65 -6 97 34 18 23 34 39 36 38 2 -2 -20 -48
-48 -102 l-50 -99 33 7 c84 17 149 19 149 5 0 -8 -37 -104 -82 -213 -74 -177
-83 -195 -86 -162 -4 50 -26 56 -66 17 -17 -17 -35 -31 -39 -31 -4 0 -7 18 -7
-40 0 28 -6 43 -18 51 -15 10 -18 21 -14 65 8 93 -18 69 -89 -80 -35 -74 -65
-133 -67 -131 -3 2 5 35 17 74 11 38 21 74 21 80 0 6 -35 11 -87 13 l-88 3 3
-30 c4 42 162 364 187 381 11 8 44 14 76 14 55 0 59 2 93 42 20 23 36 45 36 50
-0 4 5 8 10 8 6 0 -1 -20 -15 -43z m1710 6 c120 -17 143 -19 164 -12 10 3 21
-17 37 -67 24 -77 75 -306 69 -312 -2 -2 -21 14 -43 37 l-39 41 -145 0 c-128
-0 -148 2 -170 19 -16 13 -29 17 -39 10 -8 -5 -17 -9 -20 -9 -10 0 -66 178 -74
-232 -4 25 -4 56 0 68 7 21 11 22 79 16 39 -4 121 -14 181 -23z m-79 -988 c74
-190 129 -303 247 -514 76 -136 79 -145 62 -157 -24 -17 -76 -18 -98 -1 -21
-16 -126 237 -165 347 -30 87 -143 516 -141 541 1 19 17 -19 95 -216z m3644 61
-c64 -163 185 -534 301 -926 66 -223 147 -490 179 -595 175 -566 250 -858 321
-1240 22 -121 43 -231 46 -245 4 -18 3 -22 -6 -15 -6 6 -22 71 -36 145 -58
-313 -100 487 -200 820 -40 135 -94 317 -120 405 -161 550 -413 1387 -465 1540
-55 165 -67 205 -56 194 2 -2 18 -39 36 -83z m-4395 -812 c61 -60 129 -118
-149 -128 46 -22 69 -19 238 25 70 18 130 30 133 27 3 -3 -19 -42 -49 -87 -53
-78 -75 -125 -63 -137 14 -14 111 32 205 96 57 38 136 85 176 104 84 40 299
-116 327 116 12 0 37 -24 66 -65 25 -36 54 -67 62 -69 9 -2 178 -1 376 2 l360
-7 10 70 c10 68 10 69 22 40 7 -16 17 -49 23 -73 14 -53 18 -55 187 -82 178
-28 191 -33 200 -78 12 -57 8 -612 -6 -742 -17 -170 -53 -395 -141 -880 -206
-1142 -248 -1540 -194 -1863 8 -49 12 -97 9 -107 -8 -24 -195 -200 -213 -200
-7 0 -21 14 -30 31 -140 256 -353 528 -467 594 -66 39 -95 39 -361 1 -137 -19
-303 -40 -368 -47 -128 -12 -307 -7 -368 11 -54 16 -140 78 -185 132 -41 51
-348 610 -438 801 -105 220 -178 478 -191 667 -7 97 11 328 25 343 5 5 23 -17
-41 -49 18 -32 72 -97 125 -148 54 -53 97 -104 101 -120 12 -50 -1 -119 -34
-170 -22 -33 -32 -62 -32 -88 0 -45 31 -126 70 -182 23 -35 28 -50 23 -82 -3
-24 4 -70 17 -119 18 -68 28 -87 68 -128 59 -60 118 -101 132 -92 6 4 10 18 8
-32 -3 22 3 28 48 44 28 11 59 28 70 40 l18 20 -107 -7 c-118 -8 -146 0 -166
-43 -17 37 -14 52 18 84 33 33 78 41 66 12 -14 -31 -16 -77 -5 -93 9 -13 14
-11 36 14 21 24 25 37 21 68 -5 37 -4 38 36 49 56 15 192 6 242 -15 l40 -17
-27 -20 c-66 -49 -1 -50 120 -2 80 31 92 40 92 64 0 33 -30 52 -72 45 -33 -5
-51 1 -140 49 -226 121 -267 139 -327 139 -31 1 -68 -3 -83 -8 -24 -7 -32 -3
-62 30 -62 67 -63 76 -30 145 53 111 38 151 -110 308 -88 93 -131 162 -142
-230 -11 67 0 84 99 164 142 113 222 232 261 384 46 178 -18 329 -188 441 -74
-48 -75 49 -51 60 35 16 31 28 -20 64 -31 22 -41 34 -32 40 21 14 168 59 252
-77 67 15 80 21 83 39 2 12 -33 92 -82 187 -100 193 -117 263 -35 144 28 -41
-102 -124 164 -185z m-430 -364 c-13 -21 19 -51 100 -97 78 -43 142 -93 119
-93 -5 0 -34 7 -64 15 -69 19 -148 19 -180 0 -24 -14 -24 -14 21 -15 63 0 238
-37 267 -56 24 -16 42 -52 42 -85 0 -17 -8 -14 -57 24 -92 71 -138 91 -213 90
-36 0 -85 -8 -109 -17 -55 -20 -64 -14 -103 71 -37 82 -36 104 4 127 60 36
-190 63 173 36z m4328 -154 c76 -37 148 -103 127 -116 -27 -17 -107 -10 -174
-15 -91 34 -212 35 -310 1 -55 -19 -76 -22 -100 -14 -17 5 -37 12 -45 14 -17 6
-18 45 66 75 76 47 131 59 258 57 109 -3 125 -6 178 -32z m-4293 -282 c3 -28
-11 -58 17 -66 7 -8 12 -30 12 -49 -1 -40 10 -72 46 -128 33 -53 32 -67 -5 -80
-78 -27 -118 37 -133 210 -10 105 -9 120 7 144 27 42 50 29 56 -31z m-53 -438
-c-4 -9 -11 -16 -17 -16 -11 0 -14 33 -3 44 11 10 26 -11 20 -28z m449 -922
-c60 -20 62 -23 44 -34 -23 -15 -104 -12 -126 5 -19 15 -19 15 0 30 24 18 22
-19 82 -1z m5843 -211 c82 -179 180 -472 218 -653 34 -160 38 -387 10 -517 -37
-172 -107 -345 -191 -471 -81 -122 -215 -266 -232 -249 -2 2 10 37 27 78 188
-447 261 1077 185 1584 -15 98 -31 196 -35 217 -10 44 0 50 18 11z m-2689 -313
-c25 -333 24 -319 22 -342 -1 -10 -66 -56 -164 -115 -175 -106 -203 -121 -196
-101 3 7 26 81 53 163 39 124 214 633 241 699 15 37 22 -12 44 -304z m110
-832 c37 -172 37 -173 -56 -257 -80 -73 -143 -103 -230 -109 -105 -7 -132 9
-183 108 -53 101 -53 132 -3 177 21 19 126 88 233 153 182 111 194 117 201 97
-3 -12 20 -88 38 -169z m-1046 -650 c67 -151 141 -236 331 -383 138 -106 239
-173 309 -204 42 -18 47 -23 36 -36 -7 -9 -110 -81 -229 -160 -178 -118 -251
-161 -416 -238 -110 -51 -250 -117 -312 -147 -62 -29 -118 -50 -126 -47 -7 3
-24 34 -36 69 -28 77 -74 158 -252 445 -75 122 -140 231 -144 242 -6 19 -2 21
-42 21 63 0 171 24 230 50 35 15 99 72 238 209 182 180 271 261 285 261 4 0 24
-37 44 -82z m-2387 -88 c-10 -81 -64 -284 -102 -378 -55 -136 -119 -238 -204
-323 -108 -107 -162 -132 -306 -137 -109 -4 -111 -3 -175 30 -42 22 -76 48
-98 78 l-35 45 114 7 c338 22 478 105 645 383 29 50 70 131 89 180 49 124 67
-165 73 165 3 0 2 -22 -1 -50z m1647 -1402 c-54 -78 -300 -358 -315 -358 -16 0
-10 15 29 76 113 173 323 408 330 370 2 -10 -18 -49 -44 -88z"/>
-<path d="M3229 5845 c-108 -15 -150 -30 -198 -71 -49 -41 -111 -123 -111 -146
-0 -18 5 -20 40 -15 22 3 40 3 40 1 0 -2 -9 -26 -20 -53 -12 -32 -16 -52 -9
-56 9 -6 7 -23 -8 -62 -3 -8 4 -13 20 -13 16 0 26 -7 30 -20 8 -30 33 -24 48
-12 15 37 122 148 142 148 12 0 11 -10 0 -56 -17 -66 -10 -118 17 -137 15 -11
-19 -21 14 -44 -5 -25 2 -39 44 -90 28 -33 66 -67 85 -76 39 -19 112 -22 152
-7 39 15 108 74 140 121 27 38 28 41 13 72 -15 32 -15 34 8 54 13 12 24 33 24
-47 l0 25 38 -17 c58 -26 111 -62 122 -81 6 -13 3 -29 -11 -57 -98 -186 -404
-264 -685 -174 -101 32 -143 37 -162 18 -21 -21 -13 -28 31 -28 49 0 82 -19
-91 -53 5 -20 11 -23 31 -19 14 2 31 0 38 -6 17 -14 145 -34 168 -27 11 4 26 1
-34 -5 9 -7 23 -9 37 -4 13 5 41 9 63 11 22 1 51 3 65 4 14 1 37 -1 52 -5 21
-6 27 -4 33 13 5 18 14 21 55 21 43 0 49 3 52 23 3 19 10 22 51 25 49 3 53 7
-37 32 -11 17 4 30 38 30 15 0 22 6 22 19 0 14 16 27 55 45 40 18 56 31 61 51
-3 14 16 32 27 40 18 13 20 18 10 34 -11 17 -8 21 25 35 100 44 116 63 55 68
-33 3 -38 6 -36 26 3 22 0 22 -45 16 -44 -6 -49 -4 -83 29 -58 56 -354 199
-469 227 -116 28 -147 43 -70 36 30 -3 108 -23 173 -45 64 -22 117 -36 117
-31 0 13 -23 24 -160 75 -142 53 -197 60 -331 40z"/>
-<path d="M3027 5303 c-3 -5 -2 -15 2 -22 7 -10 10 -10 16 -1 4 6 3 16 -3 22
-5 5 -12 6 -15 1z"/>
-<path d="M2180 4462 c0 -11 136 -122 149 -122 19 0 12 46 -11 75 -12 15 -36
-34 -54 41 -37 15 -84 19 -84 6z"/>
-</g></g></svg>
@@ -1,242 +0,0 @@
-<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 500 500" width="500" height="500">
-	<style>
-		.s0 { fill: #f6f4f4 } 
-		.s1 { fill: #0b0303 } 
-		.s2 { fill: #ef0011 } 
-		.s3 { fill: #f3e2e2 } 
-		.s4 { fill: #f00212 } 
-		.s5 { fill: #ba000d } 
-		.s6 { fill: #faf1f1 } 
-		.s7 { fill: #0b0100 } 
-		.s8 { fill: #fbedee } 
-		.s9 { fill: #faeaea } 
-		.s10 { fill: #ab797d } 
-		.s11 { fill: #f8eaea } 
-		.s12 { fill: #902021 } 
-		.s13 { fill: #f9eeee } 
-		.s14 { fill: #f6ecec } 
-		.s15 { fill: #080201 } 
-		.s16 { fill: #150100 } 
-		.s17 { fill: #f2e7e7 } 
-		.s18 { fill: #fbe7e8 } 
-		.s19 { fill: #060101 } 
-		.s20 { fill: #f5e7e7 } 
-		.s21 { fill: #fa999e } 
-		.s22 { fill: #c46064 } 
-		.s23 { fill: #180300 } 
-		.s24 { fill: #f6dcdd } 
-		.s25 { fill: #f2e6e6 } 
-		.s26 { fill: #110200 } 
-		.s27 { fill: #eb0011 } 
-		.s28 { fill: #e20010 } 
-		.s29 { fill: #ea0011 } 
-		.s30 { fill: #760007 } 
-		.s31 { fill: #f00514 } 
-		.s32 { fill: #fcebeb } 
-		.s33 { fill: #ecd6d6 } 
-		.s34 { fill: #f5e3e3 } 
-		.s35 { fill: #f5e4e4 } 
-		.s36 { fill: #faf6f6 } 
-		.s37 { fill: #e50010 } 
-		.s38 { fill: #d5000f } 
-		.s39 { fill: #f2e2e3 } 
-		.s40 { fill: #ef1018 } 
-		.s41 { fill: #f4e8e9 } 
-		.s42 { fill: #ef0513 } 
-		.s43 { fill: #f5e5e5 } 
-		.s44 { fill: #f00413 } 
-		.s45 { fill: #f4e9ea } 
-		.s46 { fill: #ed0011 } 
-		.s47 { fill: #e80011 } 
-		.s48 { fill: #e60613 } 
-		.s49 { fill: #f0d6d6 } 
-		.s50 { fill: #fca9ac } 
-		.s51 { fill: #9c000c } 
-		.s52 { fill: #73393b } 
-	</style>
-	<g>
-		<path fill-rule="evenodd" class="s0" d="m166.5 52.5q3.5 0 7 0 2.75 2.99 1.5 7-21.27 45.61-20.5 96 39.99 2.76 72 26.5 7.87 6.86 13.5 15.5 42.88-56.39 103.5-92.5 47.35-25.46 101-25 14.52 0.38 23.5 11.5 3.19 7.74 2 16-1.81 7.18-4.5 14-1 0-1 1-5.04 6.05-9 13-1 0-1 1 0 0.5 0 1-12.42 12.15-28.5 19-6.02 36.27-41.5 45-0.83 2.75 0 5 19.02-12.85 41.5-9 10.85-8.09 23.5-13 15.01-6.37 31-2.5 14.09 7.43 14 23.5-2.83 23.25-15.5 43-6.42 9.92-14 19-10.04 8.8-19.5 18-72.02 48.88-156.5 27-19.63 9.6-41.5 10.5-4.59 1.27-9 3 2 1 4 2 20.09-1.11 35 12 25.46 6.95 37.5 30.5 1.26 5.69-1 11-3.38 3.79-7.5 6.5 5.74 10.07 1.5 20.5-7.55 7.47-17.5 3.5-11.01-5.34-22.5-9.5-18.26 10-38.5 13-15.5 0-31 0-26.62-4.54-51-17-4.17 1.33-8 3.5-7.23 5.87-15 11-8.62 2.58-13.5-4.5-1.82 2.32-4.5 3.5-6.06 2.24-12 3.5-7.5 0-15 0-27.42-2.56-50-18.5-18-17.25-23-41.5 0-11.5 0-23 4.12-22.7 25-33 6.95-16.67 22-26.5-20.39-20.8-14.5-49.5 7.01-26.98 28.5-44.5 7.56-5.27 15-10.5-13.09-30.88-7.5-64 3.16-15.57 14.5-26.5 6.85-2.48 8 4.5-6.59 39.53 11 75.5 7.99-0.49 16-2 2.42-34.57 14.5-67.5 8.51-22.23 27.5-36z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s1" d="m113.5 401.5q0.48-5.1-1-10-0.91 0.19-1 1-2.46 1.74-5 3.5 5.65 9.54-5 13-32.21 5.55-61-10-32.89-23.11-29.5-63.5 2.96-22.67 23.5-32 7.99-19.75 27-29.5-27.65-23.7-15.5-58.5 7.33-16.82 20.5-29.5 10.79-8.14 22-15.5-16.49-37.08-5.5-76 3.19-6.13 7.5-11.5 1.48-0.89 2 1-5.69 41.09 12.5 78.5 1 1 2 2 9.97-3.24 20.5-4 2 0 4 0 0-7.5 0-15 0.99-42.22 24.5-77 6.12-7.12 14-12-4.65 13.43-10 27-11.93 37.6-9.5 77 49.38 0.7 83.5 36 2.75 4.5 5.5 9 38.99-52.24 93-88.5 45.84-29.03 100-32.5 15.69-1.56 29 6.5 5.68 7.29 3.5 16.5-10.38 33.62-43.5 45-4.39 37.33-41 45-0.79 8.63-6 15.5 1.91 1.83 4.5 2.5 22.27-17.25 50.5-14.5 12.93-9.41 28-15 36.22-8.28 31.5 28.5-15.19 51.69-62.5 77.5-65.92 35.87-138 15.5-19.67 10.42-42 10.5-8.39 2.88-17 5 3.58 6.08 10 9 20.92-1.14 36 13 22.67 5.23 34.5 25.5 3.33 7.13-3.5 11.5-3.88 1.8-8 3 7.36 8.45 6.5 19.5-4.43 5.66-11.5 3.5-12.84-5.67-26-10.5-39.4 21.02-83 10.5-18.85-5.78-36.5-14.5-13.65 4.14-23.5 14.5-9.51 3.74-11-6.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s2" d="m153.5 173.5q24.62 1.46 46 13.5 12.11 8.1 17.5 21.5 0.74 2.45 0.5 5 0.09 0.81 1 1 1.48-4.9 1-10 5.04 10.48 1.5 22-9.81 27.86-35.5 42.5-26.17 14.97-56 19.5-2.77-0.4-2 1 2.86 1.27 6 1 25.64 1.53 48.5-10 0.34 10.08 2 20 1.08 5.76 5 10 1 1.5 0 3-31.11 20.84-68.5 17.5-23.7-5.7-32.5-28.5-4.39-9.18-3.5-19 15.41 6.23 32 4.5-20.68-6.39-39-18-34.81-27.22-12.5-65.5 11.84-14.83 29-23 4.21 7.66 11.5 12.5 3 1 6 0-26.04-34.62-29-78-0.13-8.46 2-16.5 1 6.5 2 13 3.43 39.53 24.5 73 2.03 2.28 4.5 4 0.5-1.25 1-2.5-1.27-6.54-5-12 0.5-0.75 1-1.5 9.72-3.43 20-4 0.55 10.34 8 17.5 1.94 0.74 4 0.5-17.8-64.6 16.5-122 0.98-1.79 1.5 0-28.21 56.64-13.5 118 1.08 1.43 2.5 0.5 2.21-4.98 2-10.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s3" d="m454.5 97.5q-18.37-2.97-37-1.5-16.14 2.08-32 5.5 32.38-14.09 67-7.5 1.98 1.22 2 3.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s4" d="m454.5 97.5q-1.33 11.18-8.5 20-21.81 26.28-55.5 32-1.11-0.2-2 0.5 2.31 2.82 5.5 4.5 1 2 0 4-9.56 11.3-19.5 20 19.71-8.72 31-27 2.68-0.43 5 1-14.24 30.97-48 36.5-9.93 1.71-20 1.5-6.8-0.48-13 1 5.81 6.92 14 11-10.78 16.03-27 26.5 27.16-7.4 38-33.5 4.34 1.35 9 1-9.08 23.84-33 33.5-18.45 6.41-38 7 22.59 8.92 45-1 12.05-5.52 24-11 9.01-1.79 17 2.5 5.28-4.38 11-8 12.8-6.07 27-5 0 0.5 0 1-19.34 2.69-34 15.5 0.5 0.25 1 0.5 17.79-8.09 36-15 2.71-0.79 5-2 2.5-1 5-2 5.53-4.04 11-8 11.7-4.18 24-6.5 7.78-1.36 15 1.5-2.97 18.45-13.5 34-34.92 49.37-94.5 62.5-59.27 12.45-108-23-15.53-12.52-21.5-31.5-2.47-14.26 4-27-3.15 24.41 14 42-4.92-10.28-7-22-1.97-17.63 7-33 47.28-69.5 125.5-100 15.86-3.42 32-5.5 18.63-1.47 37 1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s5" d="m86.5 112.5q-1-6.5-2-13 0.7-5.34 3.5-10-1.8 11.32-1.5 23z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s6" d="m433.5 97.5q2.22-0.39 4 1-10 13.75-27 14-0.24-2.06 0.5-4 10.3-7.78 22.5-11z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s7" d="m407.5 101.5q2.55-0.24 5 0.5-52.87 18.31-84.5 64.5-6.94 7.95-17 11-9.38-2.38-5-11 40.38-48.62 101.5-65z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s8" d="m402.5 112.5q3 0 6 0-2.56 8.8-12 7-0.22-1.58 0.5-3 2.72-2.22 5.5-4z"/>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s9" d="m390.5 149.5q7.77 0.52 15 2-11.29 18.28-31 27 9.94-8.7 19.5-20 1-2 0-4-3.19-1.68-5.5-4.5 0.89-0.7 2-0.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s10" d="m131.5 145.5q0 7.5 0 15-2 0-4 0 1.06-1.36 3-1-0.48-7.29 1-14z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s11" d="m219.5 204.5q-1 4.5-2 9 0.24-2.55-0.5-5-5.39-13.4-17.5-21.5-21.38-12.04-46-13.5 0-2 0-4 36.7-0.86 61.5 26 3.06 4.11 4.5 9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s12" d="m329.5 191.5q6.2-1.48 13-1-3.5 1-7 2-2.9-0.97-6-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s13" d="m329.5 191.5q3.1 0.03 6 1 9.55 1.31 19 3-10.84 26.1-38 33.5 16.22-10.47 27-26.5-8.19-4.08-14-11z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s14" d="m479.5 199.5q-7.22-2.86-15-1.5-12.3 2.32-24 6.5 15.6-13.11 36-11.5 3.63 2.26 3 6.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s15" d="m193.5 216.5q-12.01 1.52-22 8-2.83 1.29-5.5 3-4.79-4.57-6.5-11-5.04 2.2-9.5-1-3.47-6.4 3.5-3 4.4 0.05 8-2.5 9.22-9.73 21-16 6.3-3.24 12 1-2.9 1.22-6 1.5 2.61 5.74 4.5 12 0.75 3.97 0.5 8z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s16" d="m458.5 200.5q3.04-0.24 6 0.5-18.02 7.05-33 19-1 1-2 0 11.53-14.3 29-19.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s17" d="m178.5 202.5q6.85-0.63 4.5 6-7.6 5.09-6-4 1.08-0.82 1.5-2z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s18" d="m469.5 201.5q-2.26 13.65-14.5 22-0.47-2.11 1-4 7.08-8.82 13.5-18z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s19" d="m74.5 208.5q8.22-0.2 16 2.5 11.8 4.26 23.5 8.5 5.65-0.63 8-6 2.41 11.83-9.5 13 0.55 3.61 2 7-0.5 1-1 2-4.67-0.94-9.5-1-9.96 0.44-19.5 2.5-5.05-3.55-6.5-9.5-0.75-7.48-0.5-15-6.47 0.15-3-4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s20" d="m429.5 212.5q-2.5 1-5 2-4 0-8 0-14.2-1.07-27 5 15.27-12.44 35-9.5 2.72 1.14 5 2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s21" d="m219.5 204.5q0.48 5.1-1 10-0.91-0.19-1-1 1-4.5 2-9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s22" d="m416.5 215.5q0-0.5 0-1 4 0 8 0-2.29 1.21-5 2-1.06-1.36-3-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s23" d="m416.5 215.5q1.94-0.36 3 1-18.21 6.91-36 15-0.5-0.25-1-0.5 14.66-12.81 34-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s24" d="m193.5 216.5q4.39 1.3 9 3-0.79 1.04-2 1.5-14.77-0.13-29 3.5 9.99-6.48 22-8z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s25" d="m98.5 219.5q6.09-0.98 6 5-3.04 0.24-6-0.5-1.84-2.24 0-4.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s26" d="m176.5 229.5q8.85-1.14 16 4-4.98 1.75-10 0-13.56 14.3-33 19.5-28.06 8.2-55 1 3.32-6.4 10-5.5-0.71 1.47-2 2.5 36.58 4.24 69-14 4.68-2.13 1-5 2.35-0.91 4-2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s27" d="m231.5 238.5q1.31-0.2 2 1-3.13 28.62 15 51-16.25 6.75-27-7.5-1-1-2 0 14.73 29.34 46 18.5 1.79 0.52 0 1.5-37.63 16.82-50.5-22.5-5.1-26.48 16.5-42z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s28" d="m243.5 259.5q5.88 3.62 10.5 9 12.96 18.46 32.5 29.5-31.51-7.75-43-38.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s29" d="m203.5 266.5q1.31-0.2 2 1-2.48 22.08 12 39-6.99 1.35-14 0.5 4.59 4.08 10 7-8.71 0.28-14.5-6.5-16.98-22.76 4.5-41z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s27" d="m58.5 284.5q9.6-2.17 14.5 6 5.15 14.18-1 28-11.05-13.14-27.5-17.5 5.15-9.9 14-16.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s30" d="m129.5 288.5q2 1 4 2-3.14 0.27-6-1-0.77-1.4 2-1z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s31" d="m56.5 313.5q3.43 5.43 8 10-4.88 0.44-8 4-1.11-0.2-2 0.5 28.91 1.65 38 28.5 0.45 3.16-1 6-11.02-7.01-23-12.5-4.75-3.75-9.5-7.5 1.47 7.42 7 13 8.34 27.18 32 43 0.99 2.41-1.5 3.5-40.25 5.58-66.5-25.5-15.67-22.01-8-48 10.46-23.87 34.5-15z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s32" d="m45.5 317.5q4.03-0.25 8 0.5 2.46 4.16-2 6-6.04 2.01-9-3.5 1.26-1.85 3-3z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s33" d="m56.5 313.5q4.91 3.14 9.5 7 0.88 2.25-1.5 3-4.57-4.57-8-10z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s34" d="m198.5 319.5q-11.1 11.56-27 15.5-15.75 4.88-32 2.5 28.81-3.69 54-18.5 2.65-0.96 5 0.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s4" d="m198.5 319.5q1.44 0.68 2.5 2 2.41 8.23 6 16 1.2 2.64-0.5 5-30.65 21.41-68 18.5-25.16-6.17-32.5-30.5 6.96 4.99 15.5 6.5 8.99 0.75 18 0.5 16.25 2.38 32-2.5 15.9-3.94 27-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s35" d="m92.5 356.5q-9.09-26.85-38-28.5 0.89-0.7 2-0.5 25.47-4.89 35.5 19 0.75 4.98 0.5 10z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s36" d="m72.5 335.5q3.62-0.38 5 3-4.22 1.83-5-3z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s37" d="m223.5 336.5q5.59-0.48 11 1-4.04 4.16-8.5 8-5.99-3.8-2.5-9z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s38" d="m90.5 334.5q0.59-1.54 2-0.5 3.94 5.45 9 10 7 6 14 12-6.91-1.7-13-6-6.21-7.72-12-15.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s39" d="m261.5 346.5q-3.54-2.44-8-3.5-6.98-0.75-14-0.5 0.63-1.08 2-1.5 13.82-2.52 26 4-2.63 1.98-6 1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s40" d="m239.5 342.5q7.02-0.25 14 0.5 4.46 1.06 8 3.5-5.2 2.35-10 5.5-3.88 4.65-9 7.5-9.89-3.09-9.5-13 2.36-3.63 6.5-4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s41" d="m214.5 349.5q-21.43 15.48-48 16 22.82-5.9 43-18.5 3.64-1.12 5 2.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s42" d="m214.5 349.5q5.96 7.2 13.5 13 1 1 0 2-28.58 23.34-65.5 20.5-18.15-4.24-27.5-19.5 1.13 0.94 2.5 1.5 14.7 1.42 29-1.5 26.57-0.52 48-16z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s43" d="m302.5 373.5q-14.74-16.73-37-19-4.55 0.25-9 1 25.3-10.24 43.5 11 2.85 2.91 2.5 7z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s44" d="m302.5 373.5q0.21 2.44-2 3.5-28.69 7.6-50.5-12.5-0.06-6.71 6.5-9 4.45-0.75 9-1 22.26 2.27 37 19z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s45" d="m100.5 356.5q5.42 2.71 11 5.5-13.04 7.54-18.5 21.5-7.57-7.14-10.5-17 5.58 1.54 10 5.5 4.2 0.84 5.5-3.5 1.41-5.99 2.5-12z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s8" d="m83.5 394.5q-18.9-10.15-29.5-29-1.54-3.52-2-7 5.79 2.39 10 7 7.82 16.63 21.5 29z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s46" d="m232.5 365.5q17.6 6.19 10.5 23-10.6 10.42-25.5 11.5-25.94 3.21-49-9 36.75-1.65 64-25.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s47" d="m113.5 367.5q7.7-0.01 9.5 7-9.69 7.19-18.5 15.5-7.23 5.76-5.5-3.5 3.12-12.84 14.5-19z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s29" d="m126.5 380.5q7.88-0.4 12 6.5-8.5 7.25-17 14.5-5.62-12.55 5-21z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s48" d="m283.5 385.5q3.22 2.95 7 5.5 2.8 4.03 6 7.5 0.42 2.77-2 4-15.5-9.75-31-19.5-1.79-0.98 0-1.5 9.96 2.49 20 4z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s49" d="m283.5 385.5q8.71-1.27 11.5 7 1.22 2.9 1.5 6-3.2-3.47-6-7.5-3.78-2.55-7-5.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s50" d="m83.5 394.5q1.88-0.06 3 1.5-2.25 0.88-3-1.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s51" d="m258.5 392.5q3.51 0.41 0 2.5-2.33 1.93-5 2 2.61-2.28 5-4.5z"/>
-	</g>
-	<g>
-		<path fill-rule="evenodd" class="s52" d="m111.5 392.5q0.09-0.81 1-1 1.48 4.9 1 10-1-4.5-2-9z"/>
-	</g>
-</svg>
@@ -1,7 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="512" height="512"><svg width="512" height="512" viewBox="0 0 512 512" fill="none" xmlns="http://www.w3.org/2000/svg">
-<rect width="512" height="512" fill="#131010"></rect>
-<path d="M320 224V352H192V224H320Z" fill="#5A5858"></path>
-<path fill-rule="evenodd" clip-rule="evenodd" d="M384 416H128V96H384V416ZM320 160H192V352H320V160Z" fill="white"></path>
-</svg><style>@media (prefers-color-scheme: light) { :root { filter: none; } }
-@media (prefers-color-scheme: dark) { :root { filter: none; } }
-</style></svg>
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
-  <rect width="800" height="800" rx="160" fill="#fff"/>
-  <path fill="#000" fill-rule="evenodd" d="
-    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
-    M282.65 282.65 V400 H400 V282.65 Z
-  "/>
-  <path fill="#000" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
-</svg>
@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800">
-  <rect width="800" height="800" rx="160" fill="#000"/>
-  <path fill="#fff" fill-rule="evenodd" d="
-    M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z
-    M282.65 282.65 V400 H400 V282.65 Z
-  "/>
-  <path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/>
-</svg>
@@ -161,7 +161,7 @@ export async function getModels(query?: string): Promise<Model[]> {
      // Add query if it's in the registry and not already in the list
      if (!exactMatch) {
        const result = await getModelUpstreamInfo(new Model({ model: query }));
-        const existsUpstream = result.exists;
+        const existsUpstream = !!result.digest && !result.error;
        if (existsUpstream) {
          filteredModels.push(new Model({ model: query }));
        }
@@ -339,7 +339,7 @@ export async function deleteChat(chatId: string): Promise<void> {
 // Get upstream information for model staleness checking
 export async function getModelUpstreamInfo(
  model: Model,
-): Promise<{ stale: boolean; exists: boolean; error?: string }> {
+): Promise<{ digest?: string; pushTime: number; error?: string }> {
  try {
    const response = await fetch(`${API_BASE}/api/v1/model/upstream`, {
      method: "POST",
@@ -353,22 +353,22 @@ export async function getModelUpstreamInfo(

    if (!response.ok) {
      console.warn(
-        `Failed to check upstream for ${model.model}: ${response.status}`,
+        `Failed to check upstream digest for ${model.model}: ${response.status}`,
      );
-      return { stale: false, exists: false };
+      return { pushTime: 0 };
    }

    const data = await response.json();

    if (data.error) {
-      console.warn(`Upstream check: ${data.error}`);
-      return { stale: false, exists: false, error: data.error };
+      console.warn(`Upstream digest check: ${data.error}`);
+      return { error: data.error, pushTime: 0 };
    }

-    return { stale: !!data.stale, exists: true };
+    return { digest: data.digest, pushTime: data.pushTime || 0 };
  } catch (error) {
    console.warn(`Error checking model staleness:`, error);
-    return { stale: false, exists: false };
+    return { pushTime: 0 };
  }
 }

@@ -406,31 +406,6 @@ export async function* pullModel(
  }
 }

-export interface ModelRecommendation {
-  model: string;
-  description: string;
-  context_length?: number;
-  max_output_tokens?: number;
-  vram_bytes?: number;
-}
-
-export interface ModelRecommendationsResponse {
-  recommendations: ModelRecommendation[];
-}
-
-export async function getModelRecommendations(): Promise<ModelRecommendation[]> {
-  const response = await fetch(
-    `${API_BASE}/api/experimental/model-recommendations`,
-  );
-  if (!response.ok) {
-    throw new Error(
-      `Failed to fetch model recommendations: ${response.statusText}`,
-    );
-  }
-  const data: ModelRecommendationsResponse = await response.json();
-  return data.recommendations || [];
-}
-
 export async function getInferenceCompute(): Promise<InferenceComputeResponse> {
  const response = await fetch(`${API_BASE}/api/v1/inference-compute`);
  if (!response.ok) {
@@ -480,15 +480,13 @@ function ChatForm({
      return;
    }

-    // Prepare attachments for submission, excluding unsupported images
-    const attachmentsToSend: FileAttachment[] = message.attachments
-      .filter(
-        (att) => hasVisionCapability || !isImageFile(att.filename),
-      )
-      .map((att) => ({
+    // Prepare attachments for submission
+    const attachmentsToSend: FileAttachment[] = message.attachments.map(
+      (att) => ({
        filename: att.filename,
        data: att.data || new Uint8Array(0), // Empty data for existing files
-      }));
+      }),
+    );

    const useWebSearch =
      supportsWebSearch && webSearchEnabled && !cloudDisabled;
@@ -738,17 +736,10 @@ function ChatForm({
        )}
        {(message.attachments.length > 0 || message.fileErrors.length > 0) && (
          <div className="flex gap-2 overflow-x-auto px-3 pt pb-3 w-full scrollbar-hide">
-            {message.attachments.map((attachment, index) => {
-              const isUnsupportedImage =
-                !hasVisionCapability && isImageFile(attachment.filename);
-              return (
+            {message.attachments.map((attachment, index) => (
              <div
                key={attachment.id}
-                className={`group flex items-center gap-2 py-2 px-3 rounded-lg transition-colors flex-shrink-0 ${
-                  isUnsupportedImage
-                    ? "bg-red-50 dark:bg-red-900/20 border border-red-200 dark:border-red-800"
-                    : "bg-neutral-50 dark:bg-neutral-700/50 hover:bg-neutral-100 dark:hover:bg-neutral-700"
-                }`}
+                className="group flex items-center gap-2 py-2 px-3 rounded-lg bg-neutral-50 dark:bg-neutral-700/50 hover:bg-neutral-100 dark:hover:bg-neutral-700 transition-colors flex-shrink-0"
              >
                {isImageFile(attachment.filename) ? (
                  <ImageThumbnail
@@ -773,16 +764,9 @@ function ChatForm({
                    />
                  </svg>
                )}
-                <div className="flex flex-col min-w-0">
-                  <span className={`text-sm max-w-36 truncate ${isUnsupportedImage ? "text-red-700 dark:text-red-300" : "text-neutral-700 dark:text-neutral-300"}`}>
-                    {attachment.filename}
-                  </span>
-                  {isUnsupportedImage && (
-                    <span className="text-xs text-red-600 dark:text-red-400 opacity-75">
-                      This model does not support images
-                    </span>
-                  )}
-                </div>
+                <span className="text-sm text-neutral-700 dark:text-neutral-300 max-w-[150px] truncate">
+                  {attachment.filename}
+                </span>
                <button
                  type="button"
                  onClick={() => removeFile(index)}
@@ -804,8 +788,7 @@ function ChatForm({
                  </svg>
                </button>
              </div>
-              );
-            })}
+            ))}
            {message.fileErrors.map((fileError, index) => (
              <div
                key={`error-${index}`}
@@ -6,13 +6,12 @@ import { getChat } from "@/api";
 import { Link } from "@/components/ui/link";
 import { useState, useRef, useEffect, useCallback, useMemo } from "react";
 import { ChatsResponse } from "@/gotypes";
-import { CogIcon, RocketLaunchIcon } from "@heroicons/react/24/outline";
+import { CogIcon } from "@heroicons/react/24/outline";

 // there's a hidden debug feature to copy a chat's data to the clipboard by
 // holding shift and clicking this many times within this many seconds
 const DEBUG_SHIFT_CLICKS_REQUIRED = 5;
 const DEBUG_SHIFT_CLICK_WINDOW_MS = 7000; // 7 seconds
-const launchSidebarRequestedKey = "ollama.launchSidebarRequested";

 interface ChatSidebarProps {
  currentChatId?: string;
@@ -268,8 +267,9 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
        <Link
          href="/c/new"
          mask={{ to: "/" }}
-          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 ${currentChatId === "new" ? "bg-neutral-100 dark:bg-neutral-800" : ""
-            }`}
+          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 ${
+            currentChatId === "new" ? "bg-neutral-100 dark:bg-neutral-800" : ""
+          }`}
          draggable={false}
        >
          <svg
@@ -283,23 +283,6 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
          </svg>
          <span className="truncate">New Chat</span>
        </Link>
-        <Link
-          to="/c/$chatId"
-          params={{ chatId: "launch" }}
-          onClick={() => {
-            if (currentChatId !== "launch") {
-              sessionStorage.setItem(launchSidebarRequestedKey, "1");
-            }
-          }}
-          className={`flex w-full items-center gap-3 rounded-lg px-2 py-2 text-left text-sm text-neutral-700 hover:bg-neutral-100 dark:hover:bg-neutral-800 dark:text-neutral-100 cursor-pointer ${currentChatId === "launch"
-            ? "bg-neutral-100 dark:bg-neutral-800"
-            : ""
-            }`}
-          draggable={false}
-        >
-          <RocketLaunchIcon className="h-5 w-5 stroke-current" />
-          <span className="truncate">Launch</span>
-        </Link>
        {isWindows && (
          <Link
            href="/settings"
@@ -321,18 +304,19 @@ export function ChatSidebar({ currentChatId }: ChatSidebarProps) {
              {group.chats.map((chat) => (
                <div
                  key={chat.id}
-                  className={`allow-context-menu flex items-center relative text-sm text-neutral-800 dark:text-neutral-400 rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 ${chat.id === currentChatId
-                    ? "bg-neutral-100 text-black dark:bg-neutral-800"
-                    : ""
-                    }`}
+                  className={`allow-context-menu flex items-center relative text-sm text-neutral-800 dark:text-neutral-400 rounded-lg hover:bg-neutral-100 dark:hover:bg-neutral-800 ${
+                    chat.id === currentChatId
+                      ? "bg-neutral-100 text-black dark:bg-neutral-800"
+                      : ""
+                  }`}
                  onMouseEnter={() => handleMouseEnter(chat.id)}
                  onContextMenu={(e) =>
                    handleContextMenu(
                      e,
                      chat.id,
                      chat.title ||
-                      chat.userExcerpt ||
-                      chat.createdAt.toLocaleString(),
+                        chat.userExcerpt ||
+                        chat.createdAt.toLocaleString(),
                    )
                  }
                >
@@ -10,7 +10,6 @@ interface CopyButtonProps {
  showLabels?: boolean;
  className?: string;
  title?: string;
-  onCopy?: () => void;
 }

 const CopyButton: React.FC<CopyButtonProps> = ({
@@ -21,7 +20,6 @@ const CopyButton: React.FC<CopyButtonProps> = ({
  showLabels = false,
  className = "",
  title = "",
-  onCopy,
 }) => {
  const [isCopied, setIsCopied] = useState(false);

@@ -50,14 +48,12 @@ const CopyButton: React.FC<CopyButtonProps> = ({
      }

      setIsCopied(true);
-      onCopy?.();
      setTimeout(() => setIsCopied(false), 2000);
    } catch (error) {
      console.error("Clipboard API failed, falling back to plain text", error);
      try {
        await navigator.clipboard.writeText(content);
        setIsCopied(true);
-        onCopy?.();
        setTimeout(() => setIsCopied(false), 2000);
      } catch (fallbackError) {
        console.error("Fallback copy also failed:", fallbackError);
@@ -1,158 +0,0 @@
-import { useSettings } from "@/hooks/useSettings";
-import CopyButton from "@/components/CopyButton";
-
-interface LaunchCommand {
-  id: string;
-  name: string;
-  command: string;
-  description: string;
-  icon: string;
-  darkIcon?: string;
-  iconClassName?: string;
-  borderless?: boolean;
-}
-
-const LAUNCH_COMMANDS: LaunchCommand[] = [
-  {
-    id: "claude",
-    name: "Claude Code",
-    command: "ollama launch claude",
-    description: "Anthropic's coding tool with subagents",
-    icon: "/launch-icons/claude-code.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "codex-app",
-    name: "Codex App",
-    command: "ollama launch codex-app",
-    description: "An AI agent you can delegate real work to, by OpenAI",
-    icon: "/launch-icons/codex-app.png",
-    iconClassName: "h-full w-full",
-  },
-  {
-    id: "hermes",
-    name: "Hermes Agent",
-    command: "ollama launch hermes",
-    description: "Self-improving AI agent built by Nous Research",
-    icon: "/launch-icons/hermes-agent.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "openclaw",
-    name: "OpenClaw",
-    command: "ollama launch openclaw",
-    description: "Personal AI with 100+ skills",
-    icon: "/launch-icons/openclaw.svg",
-  },
-  {
-    id: "opencode",
-    name: "OpenCode",
-    command: "ollama launch opencode",
-    description: "Anomaly's open-source coding agent",
-    icon: "/launch-icons/opencode.svg",
-    iconClassName: "h-7 w-7 rounded",
-  },
-  {
-    id: "codex",
-    name: "Codex",
-    command: "ollama launch codex",
-    description: "OpenAI's open-source coding agent",
-    icon: "/launch-icons/codex.svg",
-    darkIcon: "/launch-icons/codex-dark.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "copilot",
-    name: "Copilot CLI",
-    command: "ollama launch copilot",
-    description: "GitHub's AI coding agent for the terminal",
-    icon: "/launch-icons/copilot.svg",
-    darkIcon: "/launch-icons/copilot-dark.svg",
-    iconClassName: "h-7 w-7",
-  },
-  {
-    id: "droid",
-    name: "Droid",
-    command: "ollama launch droid",
-    description: "Factory's coding agent across terminal and IDEs",
-    icon: "/launch-icons/droid.svg",
-  },
-  {
-    id: "pi",
-    name: "Pi",
-    command: "ollama launch pi",
-    description: "Minimal AI agent toolkit with plugin support",
-    icon: "/launch-icons/pi.svg",
-    darkIcon: "/launch-icons/pi-dark.svg",
-    iconClassName: "h-7 w-7",
-  },
-];
-
-export default function LaunchCommands() {
-  const isWindows = navigator.platform.toLowerCase().includes("win");
-  const { setSettings } = useSettings();
-
-  const renderCommandCard = (item: LaunchCommand) => (
-    <div key={item.command} className="w-full text-left">
-      <div className="flex items-start gap-4 sm:gap-5">
-        <div
-          aria-hidden="true"
-          className={`flex h-10 w-10 shrink-0 items-center justify-center rounded-lg overflow-hidden ${item.borderless ? "" : "border border-neutral-200 bg-white dark:border-neutral-700 dark:bg-neutral-900"}`}
-        >
-          {item.darkIcon ? (
-            <picture>
-              <source srcSet={item.darkIcon} media="(prefers-color-scheme: dark)" />
-              <img src={item.icon} alt="" className={`${item.iconClassName ?? "h-8 w-8"} rounded-sm`} />
-            </picture>
-          ) : (
-            <img src={item.icon} alt="" className={item.borderless ? "h-full w-full rounded-xl" : `${item.iconClassName ?? "h-8 w-8"} rounded-sm`} />
-          )}
-        </div>
-
-        <div className="min-w-0 flex-1">
-          <span className="text-sm font-medium text-neutral-900 dark:text-neutral-100">
-            {item.name}
-          </span>
-          <p className="mt-0.5 text-xs text-neutral-500 dark:text-neutral-400">
-            {item.description}
-          </p>
-          <div className="mt-2 flex items-center gap-2 rounded-xl border-neutral-200 dark:border-neutral-700 bg-neutral-50 dark:bg-neutral-800 px-3 py-2">
-            <code className="min-w-0 flex-1 truncate text-xs text-neutral-600 dark:text-neutral-300">
-              {item.command}
-            </code>
-            <CopyButton
-              content={item.command}
-              size="md"
-              title="Copy command to clipboard"
-              className="text-neutral-500 dark:text-neutral-400 hover:text-neutral-700 dark:hover:text-neutral-200 hover:bg-neutral-200/60 dark:hover:bg-neutral-700/70"
-              onCopy={() => {
-                setSettings({ LastHomeView: item.id }).catch(() => { });
-              }}
-            />
-          </div>
-        </div>
-      </div>
-    </div>
-  );
-
-  return (
-    <main className="flex h-screen w-full flex-col relative">
-      <section
-        className={`flex-1 overflow-y-auto overscroll-contain relative min-h-0 ${isWindows ? "xl:pt-4" : "xl:pt-8"}`}
-      >
-        <div className="max-w-[730px] mx-auto w-full px-4 pt-4 pb-20 sm:px-6 sm:pt-6 sm:pb-24 lg:px-8 lg:pt-8 lg:pb-28">
-          <h1 className="text-xl font-semibold text-neutral-900 dark:text-neutral-100">
-            Launch
-          </h1>
-          <p className="mt-1 text-sm text-neutral-500 dark:text-neutral-400">
-            Copy a command and run it in your terminal.
-          </p>
-
-          <div className="mt-6 grid gap-7">
-            {LAUNCH_COMMANDS.map(renderCommandCard)}
-          </div>
-        </div>
-      </section>
-    </main>
-  );
-}
@@ -536,7 +536,7 @@ function ToolCallDisplay({
    let args: Record<string, unknown> | null = null;
    try {
      args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
-    } catch {
+    } catch (e) {
      args = null;
    }
    const query = args && typeof args.query === "string" ? args.query : "";
@@ -562,7 +562,7 @@ function ToolCallDisplay({
    let args: Record<string, unknown> | null = null;
    try {
      args = JSON.parse(toolCall.function.arguments) as Record<string, unknown>;
-    } catch {
+    } catch (e) {
      args = null;
    }
    const url = args && typeof args.url === "string" ? args.url : "";
@@ -73,7 +73,7 @@ export default function MessageList({
                    ? String(args.url).trim()
                    : "";
              if (candidate) lastQuery = candidate;
-            } catch { /* ignored */ }
+            } catch {}
          }
        }
      }
@@ -61,7 +61,24 @@ export const ModelPicker = forwardRef<
    try {
      const upstreamInfo = await getModelUpstreamInfo(model);

-      if (upstreamInfo.stale) {
+      // Compare local digest with upstream digest
+      let isStale =
+        model.digest &&
+        upstreamInfo.digest &&
+        model.digest !== upstreamInfo.digest;
+
+      // If the model has a modified time and upstream has a push time,
+      // check if the model was modified after the push time - if so, it's not stale
+      if (isStale && model.modified_at && upstreamInfo.pushTime > 0) {
+        const modifiedAtTime =
+          new Date(model.modified_at as string | number | Date).getTime() /
+          1000;
+        if (modifiedAtTime > upstreamInfo.pushTime) {
+          isStale = false;
+        }
+      }
+
+      if (isStale) {
        const currentStaleModels =
          queryClient.getQueryData<Map<string, boolean>>(["staleModels"]) ||
          new Map();
@@ -214,7 +214,6 @@ export default function Settings() {
        Agent: false,
        Tools: false,
        ContextLength: 0,
-        AutoUpdateEnabled: true,
      });
      updateSettingsMutation.mutate(defaultSettings);
    }
@@ -273,10 +272,6 @@ export default function Settings() {
  }

  const isWindows = navigator.platform.toLowerCase().includes("win");
-  const handleCloseSettings = () => {
-    const chatId = settings.LastHomeView === "chat" ? "new" : "launch";
-    navigate({ to: "/c/$chatId", params: { chatId } });
-  };

  return (
    <main className="flex h-screen w-full flex-col select-none dark:bg-neutral-900">
@@ -290,7 +285,7 @@ export default function Settings() {
        >
          {isWindows && (
            <button
-              onClick={handleCloseSettings}
+              onClick={() => navigate({ to: "/" })}
              className="hover:bg-neutral-100 mr-3 dark:hover:bg-neutral-800 rounded-full p-1.5"
            >
              <ArrowLeftIcon className="w-5 h-5 dark:text-white" />
@@ -300,7 +295,7 @@ export default function Settings() {
        </h1>
        {!isWindows && (
          <button
-            onClick={handleCloseSettings}
+            onClick={() => navigate({ to: "/" })}
            className="p-1 hover:bg-neutral-100 mr-3 dark:hover:bg-neutral-800 rounded-full"
          >
            <XMarkIcon className="w-6 h-6 dark:text-white" />
@@ -65,7 +65,7 @@ export const BadgeButton = forwardRef(function BadgeButton(
    ),
  ref: React.ForwardedRef<HTMLElement>,
 ) {
-  const classes = clsx(
+  let classes = clsx(
    className,
    "group relative inline-flex rounded-md focus:not-data-focus:outline-hidden data-focus:outline-2 data-focus:outline-offset-2 data-focus:outline-blue-500",
  );
@@ -171,7 +171,7 @@ export const Button = forwardRef(function Button(
  { color, outline, plain, className, children, ...props }: ButtonProps,
  ref: React.ForwardedRef<HTMLElement>,
 ) {
-  const classes = clsx(
+  let classes = clsx(
    className,
    styles.base,
    outline
@@ -381,7 +381,7 @@ export const useSendMessage = (chatId: string) => {
                    role: "assistant",
                    content: "",
                    thinking: "",
-                    model: effectiveModel.model,
+                    model: effectiveModel,
                  }),
                );
                lastMessage = newMessages[newMessages.length - 1];
@@ -433,7 +433,7 @@ export const useSendMessage = (chatId: string) => {
                    role: "assistant",
                    content: "",
                    thinking: "",
-                    model: effectiveModel.model,
+                    model: effectiveModel,
                  }),
                );
                lastMessage = newMessages[newMessages.length - 1];
@@ -520,7 +520,7 @@ export const useSendMessage = (chatId: string) => {
                    thinkingTimeStart:
                      lastMessage.thinkingTimeStart || event.thinkingTimeStart,
                    thinkingTimeEnd: event.thinkingTimeEnd,
-                    model: selectedModel.model,
+                    model: selectedModel,
                  });
                  newMessages[newMessages.length - 1] = updatedMessage;
                } else {
@@ -533,7 +533,7 @@ export const useSendMessage = (chatId: string) => {
                      tool_calls: event.toolCalls,
                      thinkingTimeStart: event.thinkingTimeStart,
                      thinkingTimeEnd: event.thinkingTimeEnd,
-                      model: selectedModel.model,
+                      model: selectedModel,
                    }),
                  );
                }
@@ -699,7 +699,7 @@ export const useSendMessage = (chatId: string) => {
            queryClient.setQueryData(["chat", newId], {
              chat: new Chat({
                id: newId,
-                model: effectiveModel.model,
+                model: effectiveModel,
                messages: [
                  new Message({
                    role: "user",
@@ -1,13 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { getModelRecommendations } from "@/api";
-import type { ModelRecommendation } from "@/api";
-
-export function useFeaturedModels() {
-  return useQuery<ModelRecommendation[], Error>({
-    queryKey: ["modelRecommendations"],
-    queryFn: getModelRecommendations,
-    staleTime: 5 * 60 * 1000,
-    gcTime: 30 * 60 * 1000,
-    refetchOnWindowFocus: false,
-  });
-}
@@ -1,49 +1,51 @@
 import { useQuery } from "@tanstack/react-query";
 import { Model } from "@/gotypes";
 import { getModels } from "@/api";
+import { mergeModels } from "@/utils/mergeModels";
 import { useMemo } from "react";
 import { useCloudStatus } from "./useCloudStatus";
-import { useFeaturedModels } from "./useFeaturedModels";

 export function useModels(searchQuery = "") {
  const { cloudDisabled } = useCloudStatus();
-  const { data: recommendations, isLoading: recommendationsLoading } =
-    useFeaturedModels();
  const localQuery = useQuery<Model[], Error>({
    queryKey: ["models", searchQuery],
    queryFn: () => getModels(searchQuery),
-    gcTime: 10 * 60 * 1000,
+    gcTime: 10 * 60 * 1000, // Keep in cache for 10 minutes
    retry: 10,
+    // exponential backoff, starting at 100ms and capping at 5s
    retryDelay: (attemptIndex) => Math.min(100 * 2 ** attemptIndex, 5000),
    refetchOnWindowFocus: true,
-    refetchInterval: 30 * 1000,
+    refetchInterval: 30 * 1000, // Refetch every 30 seconds to keep models updated
    refetchIntervalInBackground: true,
  });

  const allModels = useMemo(() => {
-    const local = localQuery.data || [];
-    const featured = (recommendations || []).map((r) => r.model);
-    const featuredSet = new Set(featured);
+    const models = mergeModels(localQuery.data || [], cloudDisabled);

-    // Recommended models first (using the local copy when downloaded),
-    // then everything else from /api/tags in tags order.
-    const recommended = featured.map(
-      (name) =>
-        local.find((m) => m.model === name) || new Model({ model: name }),
-    );
-    const rest = local.filter((m) => !featuredSet.has(m.model));
-    const merged = [...recommended, ...rest];
+    if (searchQuery && searchQuery.trim()) {
+      const query = searchQuery.toLowerCase().trim();
+      const filteredModels = models.filter((model) =>
+        model.model.toLowerCase().includes(query),
+      );

-    const visible = cloudDisabled
-      ? merged.filter((m) => !m.isCloud())
-      : merged;
-    return filterBySearch(visible, searchQuery);
-  }, [localQuery.data, searchQuery, cloudDisabled, recommendations]);
+      const seen = new Set<string>();
+      return filteredModels.filter((model) => {
+        const currentModel = model.model.toLowerCase();
+        if (seen.has(currentModel)) {
+          return false;
+        }
+        seen.add(currentModel);
+        return true;
+      });
+    }
+
+    return models;
+  }, [localQuery.data, searchQuery, cloudDisabled]);

  return {
    ...localQuery,
    data: allModels,
-    isLoading: localQuery.isLoading || recommendationsLoading,
+    isLoading: localQuery.isLoading,
  };
 }

@@ -51,16 +53,3 @@ export function useRefetchModels() {
  const { refetch } = useModels();
  return refetch;
 }
-
-function filterBySearch(models: Model[], query: string): Model[] {
-  const q = query.trim().toLowerCase();
-  if (!q) return models;
-
-  const seen = new Set<string>();
-  return models.filter((m) => {
-    const name = m.model.toLowerCase();
-    if (!name.includes(q) || seen.has(name)) return false;
-    seen.add(name);
-    return true;
-  });
-}
@@ -4,6 +4,7 @@ import { useModels } from "./useModels";
 import { useChat } from "./useChats";
 import { useSettings } from "./useSettings.ts";
 import { Model } from "@/gotypes";
+import { FEATURED_MODELS } from "@/utils/mergeModels";
 import { getTotalVRAM } from "@/utils/vram.ts";
 import { getInferenceCompute } from "@/api";
 import { useCloudStatus } from "./useCloudStatus";
@@ -91,7 +92,9 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
      (settings.selectedModel &&
        new Model({
          model: settings.selectedModel,
-          cloud: settings.selectedModel.endsWith("cloud"),
+          cloud: FEATURED_MODELS.some(
+            (f) => f.endsWith("cloud") && f === settings.selectedModel,
+          ),
          ollama_host: false,
        })) ||
      null
@@ -9,7 +9,6 @@ interface SettingsState {
  webSearchEnabled: boolean;
  selectedModel: string;
  sidebarOpen: boolean;
-  lastHomeView: string;
  thinkEnabled: boolean;
  thinkLevel: string;
 }
@@ -22,7 +21,6 @@ type SettingsUpdate = Partial<{
  ThinkLevel: string;
  SelectedModel: string;
  SidebarOpen: boolean;
-  LastHomeView: string;
 }>;

 export function useSettings() {
@@ -52,7 +50,6 @@ export function useSettings() {
      thinkLevel: settingsData?.settings?.ThinkLevel ?? "none",
      selectedModel: settingsData?.settings?.SelectedModel ?? "",
      sidebarOpen: settingsData?.settings?.SidebarOpen ?? false,
-      lastHomeView: settingsData?.settings?.LastHomeView ?? "launch",
    }),
    [settingsData?.settings],
  );
@@ -4,37 +4,12 @@ import Chat from "@/components/Chat";
 import { getChat } from "@/api";
 import { SidebarLayout } from "@/components/layout/layout";
 import { ChatSidebar } from "@/components/ChatSidebar";
-import LaunchCommands from "@/components/LaunchCommands";
-import { useEffect, useRef } from "react";
-import { useSettings } from "@/hooks/useSettings";
-
-const launchSidebarRequestedKey = "ollama.launchSidebarRequested";
-const launchSidebarSeenKey = "ollama.launchSidebarSeen";
-const fallbackSessionState = new Map<string, string>();
-
-function getSessionState() {
-  if (typeof sessionStorage !== "undefined") {
-    return sessionStorage;
-  }
-
-  return {
-    getItem(key: string) {
-      return fallbackSessionState.get(key) ?? null;
-    },
-    setItem(key: string, value: string) {
-      fallbackSessionState.set(key, value);
-    },
-    removeItem(key: string) {
-      fallbackSessionState.delete(key);
-    },
-  };
-}

 export const Route = createFileRoute("/c/$chatId")({
  component: RouteComponent,
  loader: async ({ context, params }) => {
-    // Skip loading for special non-chat views
-    if (params.chatId !== "new" && params.chatId !== "launch") {
+    // Skip loading for "new" chat
+    if (params.chatId !== "new") {
      context.queryClient.ensureQueryData({
        queryKey: ["chat", params.chatId],
        queryFn: () => getChat(params.chatId),
@@ -46,70 +21,13 @@ export const Route = createFileRoute("/c/$chatId")({

 function RouteComponent() {
  const { chatId } = Route.useParams();
-  const { settingsData, setSettings } = useSettings();
-  const previousChatIdRef = useRef<string | null>(null);

-  // Always call hooks at the top level - use a flag to skip data when chatId is a special view
+  // Always call hooks at the top level - use a flag to skip data when chatId is "new"
  const {
    data: chatData,
    isLoading: chatLoading,
    error: chatError,
-  } = useChat(chatId === "new" || chatId === "launch" ? "" : chatId);
-
-  useEffect(() => {
-    if (!settingsData) {
-      return;
-    }
-
-    const previousChatId = previousChatIdRef.current;
-    previousChatIdRef.current = chatId;
-
-    if (chatId === "launch") {
-      const sessionState = getSessionState();
-      const shouldOpenSidebar =
-        previousChatId !== "launch" &&
-        (() => {
-          if (sessionState.getItem(launchSidebarRequestedKey) === "1") {
-            sessionState.removeItem(launchSidebarRequestedKey);
-            sessionState.setItem(launchSidebarSeenKey, "1");
-            return true;
-          }
-
-          if (sessionState.getItem(launchSidebarSeenKey) !== "1") {
-            sessionState.setItem(launchSidebarSeenKey, "1");
-            return true;
-          }
-
-          return false;
-        })();
-      const updates: { LastHomeView?: string; SidebarOpen?: boolean } = {};
-
-      if (settingsData.LastHomeView !== "launch") {
-        updates.LastHomeView = "launch";
-      }
-
-      if (shouldOpenSidebar && !settingsData.SidebarOpen) {
-        updates.SidebarOpen = true;
-      }
-
-      if (Object.keys(updates).length === 0) {
-        return;
-      }
-
-      setSettings(updates).catch(() => {
-        // Best effort persistence for home view preference.
-      });
-      return;
-    }
-
-    if (settingsData.LastHomeView === "chat") {
-      return;
-    }
-
-    setSettings({ LastHomeView: "chat" }).catch(() => {
-      // Best effort persistence for home view preference.
-    });
-  }, [chatId, settingsData, setSettings]);
+  } = useChat(chatId === "new" ? "" : chatId);

  // Handle "new" chat case - just use Chat component which handles everything
  if (chatId === "new") {
@@ -120,14 +38,6 @@ function RouteComponent() {
    );
  }

-  if (chatId === "launch") {
-    return (
-      <SidebarLayout sidebar={<ChatSidebar currentChatId={chatId} />}>
-        <LaunchCommands />
-      </SidebarLayout>
-    );
-  }
-
  // Handle existing chat case
  if (chatLoading) {
    return (
@@ -1,18 +1,10 @@
 import { createFileRoute, redirect } from "@tanstack/react-router";
-import { getSettings } from "@/api";

 export const Route = createFileRoute("/")({
-  beforeLoad: async ({ context }) => {
-    const settingsData = await context.queryClient.ensureQueryData({
-      queryKey: ["settings"],
-      queryFn: getSettings,
-    });
-    const chatId =
-      settingsData?.settings?.LastHomeView === "chat" ? "new" : "launch";
-
+  beforeLoad: () => {
    throw redirect({
      to: "/c/$chatId",
-      params: { chatId },
+      params: { chatId: "new" },
      mask: {
        to: "/",
      },
@@ -1,57 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from "vitest";
-import { copyTextToClipboard } from "./clipboard";
-
-describe("copyTextToClipboard", () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it("copies via Clipboard API when available", async () => {
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    vi.stubGlobal("navigator", {
-      clipboard: {
-        writeText,
-      },
-    });
-
-    const copied = await copyTextToClipboard("ollama launch claude");
-
-    expect(copied).toBe(true);
-    expect(writeText).toHaveBeenCalledWith("ollama launch claude");
-  });
-
-  it("falls back to execCommand when Clipboard API fails", async () => {
-    const writeText = vi.fn().mockRejectedValue(new Error("not allowed"));
-    vi.stubGlobal("navigator", {
-      clipboard: {
-        writeText,
-      },
-    });
-
-    const textarea = {
-      value: "",
-      setAttribute: vi.fn(),
-      style: {} as Record<string, string>,
-      focus: vi.fn(),
-      select: vi.fn(),
-    };
-    const appendChild = vi.fn();
-    const removeChild = vi.fn();
-    const execCommand = vi.fn().mockReturnValue(true);
-    vi.stubGlobal("document", {
-      createElement: vi.fn().mockReturnValue(textarea),
-      body: {
-        appendChild,
-        removeChild,
-      },
-      execCommand,
-    });
-
-    const copied = await copyTextToClipboard("ollama launch openclaw");
-
-    expect(copied).toBe(true);
-    expect(execCommand).toHaveBeenCalledWith("copy");
-    expect(appendChild).toHaveBeenCalled();
-    expect(removeChild).toHaveBeenCalled();
-  });
-});
@@ -1,30 +0,0 @@
-export async function copyTextToClipboard(text: string): Promise<boolean> {
-  try {
-    await navigator.clipboard.writeText(text);
-    return true;
-  } catch (clipboardError) {
-    console.error(
-      "Clipboard API failed, falling back to execCommand",
-      clipboardError,
-    );
-  }
-
-  try {
-    const textarea = document.createElement("textarea");
-    textarea.value = text;
-    textarea.setAttribute("readonly", "true");
-    textarea.style.position = "fixed";
-    textarea.style.left = "-9999px";
-    textarea.style.opacity = "0";
-    document.body.appendChild(textarea);
-    textarea.focus();
-    textarea.select();
-
-    const copied = document.execCommand("copy");
-    document.body.removeChild(textarea);
-    return copied;
-  } catch (fallbackError) {
-    console.error("Fallback copy failed", fallbackError);
-    return false;
-  }
-}
@@ -29,15 +29,13 @@ describe("fileValidation", () => {
      expect(result.valid).toBe(true);
    });

-    it("should accept images regardless of vision capability", () => {
-      // Vision capability check is handled at the UI layer (ChatForm),
-      // not at validation time, so users can switch models without
-      // needing to re-upload files.
+    it("should reject WebP images when vision capability is disabled", () => {
      const file = createMockFile("test.webp", 1024, "image/webp");
      const result = validateFile(file, {
        hasVisionCapability: false,
      });
-      expect(result.valid).toBe(true);
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("This model does not support images");
    });

    it("should accept PNG images when vision capability is enabled", () => {
@@ -63,6 +63,7 @@ export function validateFile(
  const {
    maxFileSize = 10,
    allowedExtensions = [...TEXT_FILE_EXTENSIONS, ...IMAGE_EXTENSIONS],
+    hasVisionCapability = false,
    customValidator,
  } = options;

@@ -82,6 +83,10 @@ export function validateFile(
    return { valid: false, error: "File type not supported" };
  }

+  if (IMAGE_EXTENSIONS.includes(fileExtension) && !hasVisionCapability) {
+    return { valid: false, error: "This model does not support images" };
+  }
+
  // File size validation
  if (file.size > MAX_FILE_SIZE) {
    return { valid: false, error: "File too large" };
@@ -0,0 +1,128 @@
+import { describe, it, expect } from "vitest";
+import { Model } from "@/gotypes";
+import { mergeModels, FEATURED_MODELS } from "@/utils/mergeModels";
+import "@/api";
+
+describe("Model merging logic", () => {
+  it("should handle cloud models with -cloud suffix", () => {
+    const localModels: Model[] = [
+      new Model({ model: "gpt-oss:120b-cloud" }),
+      new Model({ model: "llama3:latest" }),
+      new Model({ model: "mistral:latest" }),
+    ];
+
+    const merged = mergeModels(localModels);
+
+    // First verify cloud models are first and in FEATURED_MODELS order
+    const cloudModels = FEATURED_MODELS.filter((m: string) =>
+      m.endsWith("cloud"),
+    );
+    for (let i = 0; i < cloudModels.length; i++) {
+      expect(merged[i].model).toBe(cloudModels[i]);
+      expect(merged[i].isCloud()).toBe(true);
+    }
+
+    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
+    const nonCloudFeatured = FEATURED_MODELS.filter(
+      (m: string) => !m.endsWith("cloud"),
+    );
+    for (let i = 0; i < nonCloudFeatured.length; i++) {
+      const model = merged[i + cloudModels.length];
+      expect(model.model).toBe(nonCloudFeatured[i]);
+      expect(model.isCloud()).toBe(false);
+    }
+
+    // Verify local models are preserved and come after featured models
+    const featuredCount = FEATURED_MODELS.length;
+    expect(merged[featuredCount].model).toBe("llama3:latest");
+    expect(merged[featuredCount + 1].model).toBe("mistral:latest");
+
+    // Length should be exactly featured models plus our local models
+    expect(merged.length).toBe(FEATURED_MODELS.length + 2);
+  });
+
+  it("should hide cloud models when cloud is disabled", () => {
+    const localModels: Model[] = [
+      new Model({ model: "gpt-oss:120b-cloud" }),
+      new Model({ model: "llama3:latest" }),
+      new Model({ model: "mistral:latest" }),
+    ];
+
+    const merged = mergeModels(localModels, true); // cloud disabled = true
+
+    // No cloud models should be present
+    const cloudModels = merged.filter((m) => m.isCloud());
+    expect(cloudModels.length).toBe(0);
+
+    // Should have non-cloud featured models
+    const nonCloudFeatured = FEATURED_MODELS.filter(
+      (m) => !m.endsWith("cloud"),
+    );
+    for (let i = 0; i < nonCloudFeatured.length; i++) {
+      const model = merged[i];
+      expect(model.model).toBe(nonCloudFeatured[i]);
+      expect(model.isCloud()).toBe(false);
+    }
+
+    // Local models should be preserved
+    const featuredCount = nonCloudFeatured.length;
+    expect(merged[featuredCount].model).toBe("llama3:latest");
+    expect(merged[featuredCount + 1].model).toBe("mistral:latest");
+  });
+
+  it("should handle empty input", () => {
+    const merged = mergeModels([]);
+
+    // First verify cloud models are first and in FEATURED_MODELS order
+    const cloudModels = FEATURED_MODELS.filter((m) => m.endsWith("cloud"));
+    for (let i = 0; i < cloudModels.length; i++) {
+      expect(merged[i].model).toBe(cloudModels[i]);
+      expect(merged[i].isCloud()).toBe(true);
+    }
+
+    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
+    const nonCloudFeatured = FEATURED_MODELS.filter(
+      (m) => !m.endsWith("cloud"),
+    );
+    for (let i = 0; i < nonCloudFeatured.length; i++) {
+      const model = merged[i + cloudModels.length];
+      expect(model.model).toBe(nonCloudFeatured[i]);
+      expect(model.isCloud()).toBe(false);
+    }
+
+    // Length should be exactly FEATURED_MODELS length
+    expect(merged.length).toBe(FEATURED_MODELS.length);
+  });
+
+  it("should sort models correctly", () => {
+    const localModels: Model[] = [
+      new Model({ model: "zephyr:latest" }),
+      new Model({ model: "alpha:latest" }),
+      new Model({ model: "gpt-oss:120b-cloud" }),
+    ];
+
+    const merged = mergeModels(localModels);
+
+    // First verify cloud models are first and in FEATURED_MODELS order
+    const cloudModels = FEATURED_MODELS.filter((m) => m.endsWith("cloud"));
+    for (let i = 0; i < cloudModels.length; i++) {
+      expect(merged[i].model).toBe(cloudModels[i]);
+      expect(merged[i].isCloud()).toBe(true);
+    }
+
+    // Then verify non-cloud featured models are next and in FEATURED_MODELS order
+    const nonCloudFeatured = FEATURED_MODELS.filter(
+      (m) => !m.endsWith("cloud"),
+    );
+    for (let i = 0; i < nonCloudFeatured.length; i++) {
+      const model = merged[i + cloudModels.length];
+      expect(model.model).toBe(nonCloudFeatured[i]);
+      expect(model.isCloud()).toBe(false);
+    }
+
+    // Non-featured local models should be at the end in alphabetical order
+    const featuredCount = FEATURED_MODELS.length;
+    expect(merged[featuredCount].model).toBe("alpha:latest");
+    expect(merged[featuredCount + 1].model).toBe("zephyr:latest");
+  });
+});
@@ -0,0 +1,101 @@
+import { Model } from "@/gotypes";
+
+// Featured models list (in priority order)
+export const FEATURED_MODELS = [
+  "gpt-oss:120b-cloud",
+  "gpt-oss:20b-cloud",
+  "deepseek-v3.1:671b-cloud",
+  "qwen3-coder:480b-cloud",
+  "qwen3-vl:235b-cloud",
+  "minimax-m2:cloud",
+  "glm-4.6:cloud",
+  "gpt-oss:120b",
+  "gpt-oss:20b",
+  "gemma3:27b",
+  "gemma3:12b",
+  "gemma3:4b",
+  "gemma3:1b",
+  "deepseek-r1:8b",
+  "qwen3-coder:30b",
+  "qwen3-vl:30b",
+  "qwen3-vl:8b",
+  "qwen3-vl:4b",
+  "qwen3:30b",
+  "qwen3:8b",
+  "qwen3:4b",
+];
+
+function alphabeticalSort(a: Model, b: Model): number {
+  return a.model.toLowerCase().localeCompare(b.model.toLowerCase());
+}
+
+//Merges models, sorting cloud models first, then other models
+export function mergeModels(
+  localModels: Model[],
+  hideCloudModels: boolean = false,
+): Model[] {
+  const allModels = (localModels || []).map((model) => model);
+
+  // 1. Get cloud models from local models and featured list
+  const cloudModels = [...allModels.filter((m) => m.isCloud())];
+
+  // Add any cloud models from FEATURED_MODELS that aren't in local models
+  FEATURED_MODELS.filter((f) => f.endsWith("cloud")).forEach((cloudModel) => {
+    if (!cloudModels.some((m) => m.model === cloudModel)) {
+      cloudModels.push(new Model({ model: cloudModel }));
+    }
+  });
+
+  // 2. Get other featured models (non-cloud)
+  const featuredModels = FEATURED_MODELS.filter(
+    (f) => !f.endsWith("cloud"),
+  ).map((model) => {
+    // Check if this model exists in local models
+    const localMatch = allModels.find(
+      (m) => m.model.toLowerCase() === model.toLowerCase(),
+    );
+
+    if (localMatch) return localMatch;
+
+    return new Model({
+      model,
+    });
+  });
+
+  // 3. Get remaining local models that aren't featured and aren't cloud models
+  const remainingModels = allModels.filter(
+    (model) =>
+      !model.isCloud() &&
+      !FEATURED_MODELS.some(
+        (f) => f.toLowerCase() === model.model.toLowerCase(),
+      ),
+  );
+
+  cloudModels.sort((a, b) => {
+    const aIndex = FEATURED_MODELS.indexOf(a.model);
+    const bIndex = FEATURED_MODELS.indexOf(b.model);
+
+    // If both are featured, sort by their position in FEATURED_MODELS
+    if (aIndex !== -1 && bIndex !== -1) {
+      return aIndex - bIndex;
+    }
+
+    // If only one is featured, featured model comes first
+    if (aIndex !== -1 && bIndex === -1) return -1;
+    if (aIndex === -1 && bIndex !== -1) return 1;
+
+    // If neither is featured, sort alphabetically
+    return a.model.toLowerCase().localeCompare(b.model.toLowerCase());
+  });
+
+  featuredModels.sort(
+    (a, b) =>
+      FEATURED_MODELS.indexOf(a.model) - FEATURED_MODELS.indexOf(b.model),
+  );
+
+  remainingModels.sort(alphabeticalSort);
+
+  return hideCloudModels
+    ? [...featuredModels, ...remainingModels]
+    : [...cloudModels, ...featuredModels, ...remainingModels];
+}
@@ -133,8 +133,9 @@ type Error struct {
 }

 type ModelUpstreamResponse struct {
-	Stale bool   `json:"stale"`
-	Error string `json:"error,omitempty"`
+	Digest   string `json:"digest,omitempty"`
+	PushTime int64  `json:"pushTime"`
+	Error    string `json:"error,omitempty"`
 }

 // Serializable data for the browser state
@@ -32,7 +32,6 @@ import (
 	"github.com/ollama/ollama/app/version"
 	ollamaAuth "github.com/ollama/ollama/auth"
 	"github.com/ollama/ollama/envconfig"
-	"github.com/ollama/ollama/manifest"
 	"github.com/ollama/ollama/types/model"
 	_ "github.com/tkrajina/typescriptify-golang-structs/typescriptify"
 )
@@ -156,7 +155,7 @@ func (s *Server) ollamaProxy() http.Handler {
 					return
 				}

-				target := envconfig.ConnectableHost()
+				target := envconfig.Host()
 				s.log().Info("configuring ollama proxy", "target", target.String())

 				newProxy := httputil.NewSingleHostReverseProxy(target)
@@ -194,7 +193,7 @@ func (s *Server) Handler() http.Handler {
 			if CORS() {
 				w.Header().Set("Access-Control-Allow-Origin", "*")
 				w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-				w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, User-Agent, Accept, X-Requested-With")
+				w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
 				w.Header().Set("Access-Control-Allow-Credentials", "true")

 				// Handle preflight requests
@@ -302,7 +301,6 @@ func (s *Server) Handler() http.Handler {
 	mux.Handle("HEAD /api/version", ollamaProxy)
 	mux.Handle("POST /api/me", ollamaProxy)
 	mux.Handle("POST /api/signout", ollamaProxy)
-	mux.Handle("GET /api/experimental/model-recommendations", ollamaProxy)

 	// React app - catch all non-API routes and serve the React app
 	mux.Handle("GET /", s.appHandler())
@@ -320,7 +318,7 @@ func (s *Server) handleError(w http.ResponseWriter, e error) {
 	if CORS() {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
-		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, User-Agent, Accept, X-Requested-With")
+		w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, X-Requested-With")
 		w.Header().Set("Access-Control-Allow-Credentials", "true")
 	}

@@ -343,18 +341,8 @@ func (t *userAgentTransport) RoundTrip(req *http.Request) (*http.Response, error

 // httpClient returns an HTTP client that automatically adds the User-Agent header
 func (s *Server) httpClient() *http.Client {
-	return userAgentHTTPClient(10 * time.Second)
-}
-
-// inferenceClient uses almost the same HTTP client, but without a timeout so
-// long requests aren't truncated
-func (s *Server) inferenceClient() *api.Client {
-	return api.NewClient(envconfig.Host(), userAgentHTTPClient(0))
-}
-
-func userAgentHTTPClient(timeout time.Duration) *http.Client {
 	return &http.Client{
-		Timeout: timeout,
+		Timeout: 10 * time.Second,
 		Transport: &userAgentTransport{
 			base: http.DefaultTransport,
 		},
@@ -732,7 +720,11 @@ func (s *Server) chat(w http.ResponseWriter, r *http.Request) error {
 	_, cancelLoading := context.WithCancel(ctx)
 	loading := false

-	c := s.inferenceClient()
+	c, err := api.ClientFromEnvironment()
+	if err != nil {
+		cancelLoading()
+		return err
+	}

 	// Check if the model exists locally by trying to show it
 	// TODO (jmorganca): skip this round trip and instead just act
@@ -1580,18 +1572,9 @@ func (s *Server) modelUpstream(w http.ResponseWriter, r *http.Request) error {
 		return json.NewEncoder(w).Encode(response)
 	}

-	n := model.ParseName(req.Model)
-	stale := true
-	if m, err := manifest.ParseNamedManifest(n); err == nil {
-		if m.Digest() == digest {
-			stale = false
-		} else if pushTime > 0 && m.FileInfo().ModTime().Unix() >= pushTime {
-			stale = false
-		}
-	}
-
 	response := responses.ModelUpstreamResponse{
-		Stale: stale,
+		Digest:   digest,
+		PushTime: pushTime,
 	}

 	w.Header().Set("Content-Type", "application/json")
@@ -1689,6 +1672,7 @@ func supportsBrowserTools(model string) bool {
 	return strings.HasPrefix(strings.ToLower(model), "gpt-oss")
 }

+
 // buildChatRequest converts store.Chat to api.ChatRequest
 func (s *Server) buildChatRequest(chat *store.Chat, model string, think any, availableTools []map[string]any) (*api.ChatRequest, error) {
 	var msgs []api.Message
@@ -15,7 +15,6 @@ import (
 	"sync/atomic"
 	"testing"

-	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/app/store"
 	"github.com/ollama/ollama/app/updater"
 )
@@ -527,33 +526,6 @@ func TestUserAgentTransport(t *testing.T) {
 	t.Logf("User-Agent transport successfully set: %s", receivedUA)
 }

-func TestInferenceClientUsesUserAgent(t *testing.T) {
-	var gotUserAgent atomic.Value
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		gotUserAgent.Store(r.Header.Get("User-Agent"))
-		w.Header().Set("Content-Type", "application/json")
-		w.Write([]byte(`{}`))
-	}))
-	defer ts.Close()
-
-	t.Setenv("OLLAMA_HOST", ts.URL)
-
-	server := &Server{}
-	client := server.inferenceClient()
-
-	_, err := client.Show(context.Background(), &api.ShowRequest{Model: "test"})
-	if err != nil {
-		t.Fatalf("show request failed: %v", err)
-	}
-
-	receivedUA, _ := gotUserAgent.Load().(string)
-	expectedUA := userAgent()
-
-	if receivedUA != expectedUA {
-		t.Errorf("User-Agent mismatch\nExpected: %s\nReceived: %s", expectedUA, receivedUA)
-	}
-}
-
 func TestSupportsBrowserTools(t *testing.T) {
 	tests := []struct {
 		model string
@@ -5,8 +5,6 @@ package updater
 import (
 	"context"
 	"crypto/rand"
-	"crypto/sha256"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -171,20 +169,22 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	if err != nil {
 		return fmt.Errorf("error checking update: %w", err)
 	}
-	resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		return fmt.Errorf("unexpected status attempting to download update %d", resp.StatusCode)
 	}
+	resp.Body.Close()
+	etag := strings.Trim(resp.Header.Get("etag"), "\"")
+	if etag == "" {
+		slog.Debug("no etag detected, falling back to filename based dedup")
+		etag = "_"
+	}
 	filename := Installer
 	_, params, err := mime.ParseMediaType(resp.Header.Get("content-disposition"))
-	if err == nil && params["filename"] != "" {
+	if err == nil {
 		filename = params["filename"]
 	}

-	stageFilename, err := updateStagePath(UpdateStageDir, resp.Header.Get("etag"), filename)
-	if err != nil {
-		return err
-	}
+	stageFilename := filepath.Join(UpdateStageDir, etag, filename)

 	// Check to see if we already have it downloaded
 	_, err = os.Stat(stageFilename)
@@ -202,14 +202,13 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 		return fmt.Errorf("error checking update: %w", err)
 	}
 	defer resp.Body.Close()
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("unexpected status attempting to download update %d", resp.StatusCode)
+	etag = strings.Trim(resp.Header.Get("etag"), "\"")
+	if etag == "" {
+		slog.Debug("no etag detected, falling back to filename based dedup") // TODO probably can get rid of this redundant log
+		etag = "_"
 	}

-	stageFilename, err = updateStagePath(UpdateStageDir, resp.Header.Get("etag"), filename)
-	if err != nil {
-		return err
-	}
+	stageFilename = filepath.Join(UpdateStageDir, etag, filename)

 	_, err = os.Stat(filepath.Dir(stageFilename))
 	if errors.Is(err, os.ErrNotExist) {
@@ -226,13 +225,10 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	if err != nil {
 		return fmt.Errorf("write payload %s: %w", stageFilename, err)
 	}
+	defer fp.Close()
 	if n, err := fp.Write(payload); err != nil || n != len(payload) {
-		_ = fp.Close()
 		return fmt.Errorf("write payload %s: %d vs %d -- %w", stageFilename, n, len(payload), err)
 	}
-	if err := fp.Close(); err != nil {
-		return fmt.Errorf("close payload %s: %w", stageFilename, err)
-	}
 	slog.Info("new update downloaded " + stageFilename)

 	if err := VerifyDownload(); err != nil {
@@ -243,61 +239,6 @@ func (u *Updater) DownloadNewRelease(ctx context.Context, updateResp UpdateRespo
 	return nil
 }

-func updateStagePath(stageDir, etag, filename string) (string, error) {
-	filename, err := safeUpdateFilename(filename)
-	if err != nil {
-		return "", err
-	}
-
-	stageDir, err = filepath.Abs(stageDir)
-	if err != nil {
-		return "", fmt.Errorf("resolve update stage dir: %w", err)
-	}
-
-	stageFilename := filepath.Join(stageDir, updateStageETagDir(etag), filename)
-	if err := ensurePathInDir(stageDir, stageFilename); err != nil {
-		return "", err
-	}
-
-	return stageFilename, nil
-}
-
-func safeUpdateFilename(filename string) (string, error) {
-	filename = strings.TrimSpace(filename)
-	if filename == "" {
-		return "", errors.New("missing update filename")
-	}
-	if filename == "." || filename == ".." ||
-		filepath.IsAbs(filename) || path.IsAbs(filename) ||
-		strings.ContainsAny(filename, `/\:`) ||
-		filepath.Base(filename) != filename || path.Base(filename) != filename {
-		return "", fmt.Errorf("unsafe update filename %q", filename)
-	}
-	return filename, nil
-}
-
-func updateStageETagDir(etag string) string {
-	etag = strings.Trim(strings.TrimSpace(etag), "\"")
-	if etag == "" {
-		slog.Debug("no etag detected, falling back to filename based dedup")
-		return "_"
-	}
-
-	sum := sha256.Sum256([]byte(etag))
-	return hex.EncodeToString(sum[:])
-}
-
-func ensurePathInDir(dir, name string) error {
-	rel, err := filepath.Rel(dir, name)
-	if err != nil {
-		return fmt.Errorf("resolve update staging path: %w", err)
-	}
-	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
-		return fmt.Errorf("update staging path escapes stage dir: %s", name)
-	}
-	return nil
-}
-
 func cleanupOldDownloads(stageDir string) {
 	files, err := os.ReadDir(stageDir)
 	if err != nil && errors.Is(err, os.ErrNotExist) {
@@ -22,15 +22,6 @@ import (
 	"golang.org/x/sys/unix"
 )

-const updateArchiveRoot = "Ollama.app"
-
-type bundleEntryScope int
-
-const (
-	bundleEntryRelative bundleEntryScope = iota
-	bundleEntryWithArchiveRoot
-)
-
 var (
 	appBackupDir   string
 	SystemWidePath = "/Applications/Ollama.app"
@@ -176,12 +167,8 @@ func DoUpgrade(interactive bool) error {
 		}
 		name := s[1]
 		if strings.HasSuffix(name, "/") {
-			d, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
-			if err != nil {
-				anyFailures = true
-				return err
-			}
-			err = os.MkdirAll(d, 0o755)
+			d := filepath.Join(BundlePath, name)
+			err := os.MkdirAll(d, 0o755)
 			if err != nil {
 				anyFailures = true
 				return fmt.Errorf("failed to mkdir %s: %w", d, err)
@@ -194,14 +181,30 @@ func DoUpgrade(interactive bool) error {
 			continue
 		}

-		destName, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
+		src, err := f.Open()
 		if err != nil {
 			anyFailures = true
-			return err
+			return fmt.Errorf("failed to open bundle file %s: %w", name, err)
 		}
-		if err := extractBundleFile(f, destName, name); err != nil {
+		destName := filepath.Join(BundlePath, name)
+		// Verify directory first
+		d := filepath.Dir(destName)
+		if _, err := os.Stat(d); err != nil {
+			err := os.MkdirAll(d, 0o755)
+			if err != nil {
+				anyFailures = true
+				return fmt.Errorf("failed to mkdir %s: %w", d, err)
+			}
+		}
+		destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
+		if err != nil {
 			anyFailures = true
-			return err
+			return fmt.Errorf("failed to open output file %s: %w", destName, err)
+		}
+		defer destFile.Close()
+		if _, err := io.Copy(destFile, src); err != nil {
+			anyFailures = true
+			return fmt.Errorf("failed to open extract file %s: %w", destName, err)
 		}
 	}
 	for _, f := range links {
@@ -222,24 +225,16 @@ func DoUpgrade(interactive bool) error {
 			return err
 		}
 		link := string(buf)
-		if link == "" {
-			anyFailures = true
-			return fmt.Errorf("bundle contains empty symlink %s", f.Name)
-		}
-		if filepath.IsAbs(link) {
+		if link[0] == '/' {
 			anyFailures = true
 			return fmt.Errorf("bundle contains absolute symlink %s -> %s", f.Name, link)
 		}
-		if !validBundleLinkTarget(name, link, bundleEntryRelative) {
+		// Don't allow links outside of Ollama.app
+		if strings.HasPrefix(filepath.Join(filepath.Dir(name), link), "..") {
 			anyFailures = true
-			return fmt.Errorf("bundle contains invalid symlink %s -> %s", f.Name, link)
+			return fmt.Errorf("bundle contains link outside of contents %s -> %s", f.Name, link)
 		}
-		destName, err := bundleEntryPath(BundlePath, name, bundleEntryRelative)
-		if err != nil {
-			anyFailures = true
-			return err
-		}
-		if err = os.Symlink(link, destName); err != nil {
+		if err = os.Symlink(link, filepath.Join(BundlePath, name)); err != nil {
 			anyFailures = true
 			return err
 		}
@@ -287,11 +282,8 @@ func verifyDownload() error {
 	links := []*zip.File{}
 	for _, f := range r.File {
 		if strings.HasSuffix(f.Name, "/") {
-			d, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
-			if err != nil {
-				return err
-			}
-			err = os.MkdirAll(d, 0o755)
+			d := filepath.Join(dir, f.Name)
+			err := os.MkdirAll(d, 0o755)
 			if err != nil {
 				return fmt.Errorf("failed to mkdir %s: %w", d, err)
 			}
@@ -302,12 +294,26 @@ func verifyDownload() error {
 			links = append(links, f)
 			continue
 		}
-		destName, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
+		src, err := f.Open()
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to open bundle file %s: %w", f.Name, err)
 		}
-		if err := extractBundleFile(f, destName, f.Name); err != nil {
-			return err
+		destName := filepath.Join(dir, f.Name)
+		// Verify directory first
+		d := filepath.Dir(destName)
+		if _, err := os.Stat(d); err != nil {
+			err := os.MkdirAll(d, 0o755)
+			if err != nil {
+				return fmt.Errorf("failed to mkdir %s: %w", d, err)
+			}
+		}
+		destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
+		if err != nil {
+			return fmt.Errorf("failed to open output file %s: %w", destName, err)
+		}
+		defer destFile.Close()
+		if _, err := io.Copy(destFile, src); err != nil {
+			return fmt.Errorf("failed to open extract file %s: %w", destName, err)
 		}
 	}
 	for _, f := range links {
@@ -320,20 +326,13 @@ func verifyDownload() error {
 			return err
 		}
 		link := string(buf)
-		if link == "" {
-			return fmt.Errorf("bundle contains empty symlink %s", f.Name)
-		}
-		if filepath.IsAbs(link) {
+		if link[0] == '/' {
 			return fmt.Errorf("bundle contains absolute symlink %s -> %s", f.Name, link)
 		}
-		if !validBundleLinkTarget(f.Name, link, bundleEntryWithArchiveRoot) {
-			return fmt.Errorf("bundle contains invalid symlink %s -> %s", f.Name, link)
+		if strings.HasPrefix(filepath.Join(filepath.Dir(f.Name), link), "..") {
+			return fmt.Errorf("bundle contains link outside of contents %s -> %s", f.Name, link)
 		}
-		destName, err := bundleEntryPath(dir, f.Name, bundleEntryWithArchiveRoot)
-		if err != nil {
-			return err
-		}
-		if err = os.Symlink(link, destName); err != nil {
+		if err = os.Symlink(link, filepath.Join(dir, f.Name)); err != nil {
 			return err
 		}
 	}
@@ -344,53 +343,6 @@ func verifyDownload() error {
 	return nil
 }

-func bundleEntryPath(root, name string, scope bundleEntryScope) (string, error) {
-	cleanName := filepath.Clean(filepath.FromSlash(name))
-	if !filepath.IsLocal(cleanName) {
-		return "", fmt.Errorf("bundle contains invalid path: %s", name)
-	}
-	if scope == bundleEntryWithArchiveRoot && cleanName != updateArchiveRoot &&
-		!strings.HasPrefix(cleanName, updateArchiveRoot+string(os.PathSeparator)) {
-		return "", fmt.Errorf("bundle contains invalid path: %s", name)
-	}
-	return filepath.Join(root, cleanName), nil
-}
-
-func extractBundleFile(f *zip.File, destName, name string) error {
-	src, err := f.Open()
-	if err != nil {
-		return fmt.Errorf("failed to open bundle file %s: %w", name, err)
-	}
-	defer src.Close()
-
-	d := filepath.Dir(destName)
-	if _, err := os.Stat(d); err != nil {
-		if err := os.MkdirAll(d, 0o755); err != nil {
-			return fmt.Errorf("failed to mkdir %s: %w", d, err)
-		}
-	}
-
-	destFile, err := os.OpenFile(destName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o755)
-	if err != nil {
-		return fmt.Errorf("failed to open output file %s: %w", destName, err)
-	}
-	defer destFile.Close()
-
-	if _, err := io.Copy(destFile, src); err != nil {
-		return fmt.Errorf("failed to open extract file %s: %w", destName, err)
-	}
-	return nil
-}
-
-func validBundleLinkTarget(name, link string, scope bundleEntryScope) bool {
-	cleanTarget := filepath.Clean(filepath.Join(filepath.Dir(filepath.FromSlash(name)), filepath.FromSlash(link)))
-	if !filepath.IsLocal(cleanTarget) {
-		return false
-	}
-	return scope == bundleEntryRelative || cleanTarget == updateArchiveRoot ||
-		strings.HasPrefix(cleanTarget, updateArchiveRoot+string(os.PathSeparator))
-}
-
 // If we detect an upgrade bundle, attempt to upgrade at startup
 func DoUpgradeAtStartup() error {
 	bundle := getStagedUpdate()
@@ -2,7 +2,6 @@ package updater

 import (
 	"archive/zip"
-	"errors"
 	"io/fs"
 	"os"
 	"path/filepath"
@@ -147,46 +146,6 @@ func TestDoUpgrade(t *testing.T) {
 	}
 }

-func TestDoUpgradeRejectsInvalidBundlePath(t *testing.T) {
-	tmpDir := t.TempDir()
-	BundlePath = filepath.Join(tmpDir, "Ollama.app")
-	appBackupDir = filepath.Join(tmpDir, "backup")
-	UpdateStageDir = filepath.Join(tmpDir, "updates")
-	UpgradeMarkerFile = filepath.Join(tmpDir, "upgraded")
-	bundle := filepath.Join(UpdateStageDir, "foo", "ollama-darwin.zip")
-	invalidTarget := filepath.Join(tmpDir, "invalid-entry")
-
-	if err := os.MkdirAll(filepath.Join(BundlePath, "Contents", "MacOS"), 0o755); err != nil {
-		t.Fatal("failed to create empty dirs")
-	}
-	if err := os.WriteFile(filepath.Join(BundlePath, "Contents", "MacOS", "Ollama"), []byte("old app"), 0o755); err != nil {
-		t.Fatal("failed to create old app")
-	}
-	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
-		t.Fatal("failed to create empty dirs")
-	}
-	if err := zipCreationHelper(bundle, []testPayload{{
-		Name: "Ollama.app/../invalid-entry",
-		Body: []byte("payload"),
-	}}); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := DoUpgrade(false); err == nil {
-		t.Fatal("expected failure with invalid bundle path")
-	} else if !strings.Contains(err.Error(), "bundle contains invalid path") {
-		t.Fatalf("unexpected error with invalid bundle path: %s", err)
-	}
-	if _, err := os.Stat(invalidTarget); err == nil {
-		t.Fatalf("invalid bundle path wrote %s", invalidTarget)
-	} else if !errors.Is(err, os.ErrNotExist) {
-		t.Fatalf("unexpected stat error for %s: %s", invalidTarget, err)
-	}
-	if _, err := os.Stat(filepath.Join(BundlePath, "Contents", "MacOS", "Ollama")); err != nil {
-		t.Fatalf("old app was not restored: %s", err)
-	}
-}
-
 func TestDoUpgradeAtStartup(t *testing.T) {
 	tmpDir := t.TempDir()
 	BundlePath = filepath.Join(tmpDir, "Ollama.app")
@@ -244,7 +203,7 @@ func TestVerifyDownloadFailures(t *testing.T) {
 		in       []testPayload
 		expected string
 	}{
-		{"invalid symlink target", []testPayload{
+		{"breakout", []testPayload{
 			{
 				Name: "Ollama.app/",
 				Body: []byte{},
@@ -253,34 +212,15 @@ func TestVerifyDownloadFailures(t *testing.T) {
 				Body: []byte("cli payload here"),
 			}, {
 				Name: "Ollama.app/Contents/MacOS/Ollama",
-				Body: []byte("../../../../invalid-target"),
+				Body: []byte("../../../../breakout"),
 				Mode: os.ModeSymlink,
 			},
-		}, "bundle contains invalid symlink"},
-		{"invalid archive symlink target", []testPayload{
-			{
-				Name: "Ollama.app/Contents/MacOS/Ollama",
-				Body: []byte("../../../invalid-target"),
-				Mode: os.ModeSymlink,
-			},
-		}, "bundle contains invalid symlink"},
+		}, "bundle contains link outside"},
 		{"absolute", []testPayload{{
 			Name: "Ollama.app/Contents/MacOS/Ollama",
 			Body: []byte("/etc/foo"),
 			Mode: os.ModeSymlink,
 		}}, "bundle contains absolute"},
-		{"invalid relative file", []testPayload{{
-			Name: "Ollama.app/../invalid-entry",
-			Body: []byte("payload"),
-		}}, "bundle contains invalid path"},
-		{"invalid relative directory", []testPayload{{
-			Name: "Ollama.app/../invalid-entry/",
-			Body: []byte{},
-		}}, "bundle contains invalid path"},
-		{"absolute file", []testPayload{{
-			Name: filepath.Join(tmpDir, "invalid-entry"),
-			Body: []byte("payload"),
-		}}, "bundle contains invalid path"},
 		{"missing", []testPayload{{
 			Name: "Ollama.app/Contents/MacOS/Ollama",
 			Body: []byte("../nothere"),
@@ -302,11 +242,6 @@ func TestVerifyDownloadFailures(t *testing.T) {
 			if err == nil || !strings.Contains(err.Error(), tt.expected) {
 				t.Fatalf("expected \"%s\" got %s", tt.expected, err)
 			}
-			if _, err := os.Stat(filepath.Join(tmpDir, "invalid-entry")); err == nil {
-				t.Fatal("invalid bundle path wrote unexpected file")
-			} else if !errors.Is(err, os.ErrNotExist) {
-				t.Fatalf("unexpected stat error for invalid file: %s", err)
-			}
 		})
 	}
 }
@@ -1,127 +0,0 @@
-//go:build (windows || darwin) && updater_live
-
-package updater
-
-import (
-	"context"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/ollama/ollama/app/store"
-	"github.com/ollama/ollama/app/version"
-)
-
-// TestLiveAppUpdate exercises the production update endpoint and downloads the
-// current OS update artifact. It is intentionally excluded from normal test
-// runs because it depends on ollama.com and downloads a release artifact.
-//
-// Run with:
-//
-//	go test -tags updater_live -run TestLiveAppUpdate ./app/updater
-func TestLiveAppUpdate(t *testing.T) {
-	const spoofedVersion = "0.20.0"
-
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
-	defer cancel()
-
-	oldUpdateStageDir := UpdateStageDir
-	oldUpdateDownloaded := UpdateDownloaded
-	oldVerifyDownload := VerifyDownload
-	oldVersion := version.Version
-	defer func() {
-		UpdateStageDir = oldUpdateStageDir
-		UpdateDownloaded = oldUpdateDownloaded
-		VerifyDownload = oldVerifyDownload
-		version.Version = oldVersion
-	}()
-
-	version.Version = spoofedVersion
-
-	expectedFilename := ""
-	switch runtime.GOOS {
-	case "windows":
-		t.Setenv("LOCALAPPDATA", t.TempDir())
-		expectedFilename = "OllamaSetup.exe"
-	case "darwin":
-		expectedFilename = "Ollama-darwin.zip"
-	default:
-		t.Fatalf("unsupported updater live test OS %q", runtime.GOOS)
-	}
-
-	UpdateStageDir = filepath.Join(t.TempDir(), "updates")
-	UpdateDownloaded = false
-	verifyCalled := false
-	VerifyDownload = func() error {
-		verifyCalled = true
-		return verifyDownload()
-	}
-
-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}}
-	defer updater.Store.Close()
-
-	available, updateResp := updater.checkForUpdate(ctx)
-	if !available {
-		t.Fatalf("expected production update check to offer an update for spoofed version %s", spoofedVersion)
-	}
-	if updateResp.UpdateURL == "" {
-		t.Fatal("production update response did not include a download URL")
-	}
-	t.Logf("production update version=%q url=%q", updateResp.UpdateVersion, updateResp.UpdateURL)
-
-	if err := updater.DownloadNewRelease(ctx, updateResp); err != nil {
-		t.Fatalf("download production update: %v", err)
-	}
-
-	staged := getStagedUpdate()
-	if staged == "" {
-		t.Fatal("production update was not staged")
-	}
-	t.Logf("staged production update at %s", staged)
-
-	assertPathInsideDir(t, UpdateStageDir, staged)
-	if filepath.Base(staged) != expectedFilename {
-		t.Fatalf("expected staged %s update filename to be %q, got %q", runtime.GOOS, expectedFilename, filepath.Base(staged))
-	}
-	expectedExt := filepath.Ext(expectedFilename)
-	if filepath.Ext(staged) != expectedExt {
-		t.Fatalf("expected staged %s update to be a %s artifact, got %s", runtime.GOOS, expectedExt, staged)
-	}
-
-	info, err := os.Stat(staged)
-	if err != nil {
-		t.Fatalf("stat staged update: %v", err)
-	}
-	if info.Size() == 0 {
-		t.Fatal("staged production update is empty")
-	}
-
-	if !verifyCalled {
-		t.Fatal("DownloadNewRelease did not call VerifyDownload")
-	}
-	t.Logf("production updater download path verified staged %s update", runtime.GOOS)
-}
-
-func assertPathInsideDir(t *testing.T, dir, name string) {
-	t.Helper()
-
-	dir, err := filepath.Abs(dir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	name, err = filepath.Abs(name)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	rel, err := filepath.Rel(dir, name)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
-		t.Fatalf("staged update escaped update stage dir: %s", name)
-	}
-}
@@ -11,9 +11,7 @@ import (
 	"log/slog"
 	"net/http"
 	"net/http/httptest"
-	"os"
 	"path/filepath"
-	"strings"
 	"sync/atomic"
 	"testing"
 	"time"
@@ -21,52 +19,6 @@ import (
 	"github.com/ollama/ollama/app/store"
 )

-func TestUpdateStagePathRejectsUnsafeFilename(t *testing.T) {
-	stageDir := t.TempDir()
-	for _, tt := range []struct {
-		name     string
-		filename string
-	}{
-		{"empty", ""},
-		{"dot", "."},
-		{"dotdot", ".."},
-		{"posix_parent", "../OllamaSetup.exe"},
-		{"windows_parent", `..\OllamaSetup.exe`},
-		{"posix_absolute_tmp", "/tmp/OllamaSetup.exe"},
-		{"darwin_absolute_app", "/Applications/Ollama.app"},
-		{"darwin_bundle_path", "Ollama.app/Contents/MacOS/Ollama"},
-		{"darwin_user_download", "~/Downloads/Ollama-darwin.zip"},
-		{"windows_absolute", `C:\Users\Public\OllamaSetup.exe`},
-		{"colon", "Ollama:Setup.exe"},
-	} {
-		t.Run(tt.name, func(t *testing.T) {
-			if _, err := updateStagePath(stageDir, "etag", tt.filename); err == nil {
-				t.Fatal("expected unsafe filename to be rejected")
-			}
-		})
-	}
-}
-
-func TestUpdateStagePathHashesETag(t *testing.T) {
-	stageDir := t.TempDir()
-	stageFilename, err := updateStagePath(stageDir, `../escaped`, "OllamaSetup.exe")
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	rel, err := filepath.Rel(stageDir, stageFilename)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if rel == ".." || strings.HasPrefix(rel, ".."+string(filepath.Separator)) || filepath.IsAbs(rel) {
-		t.Fatalf("stage filename escaped stage dir: %s", stageFilename)
-	}
-	etagDir := filepath.Base(filepath.Dir(stageFilename))
-	if etagDir == ".." || etagDir == "escaped" || strings.ContainsAny(etagDir, `/\`) {
-		t.Fatalf("stage filename used raw etag path component: %s", stageFilename)
-	}
-}
-
 func TestIsNewReleaseAvailable(t *testing.T) {
 	slog.SetLogLoggerLevel(slog.LevelDebug)
 	var server *httptest.Server
@@ -95,223 +47,6 @@ func TestIsNewReleaseAvailable(t *testing.T) {
 	}
 }

-func TestDownloadNewReleaseRejectsUnsafeHeaderFilename(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	oldInstaller := Installer
-	oldVerifyDownload := VerifyDownload
-	oldUpdateDownloaded := UpdateDownloaded
-	defer func() {
-		Installer = oldInstaller
-		VerifyDownload = oldVerifyDownload
-		UpdateDownloaded = oldUpdateDownloaded
-	}()
-	Installer = "OllamaSetup.exe"
-	UpdateDownloaded = false
-	VerifyDownload = func() error {
-		t.Fatal("verification should not run for rejected downloads")
-		return nil
-	}
-
-	var getAttempted atomic.Bool
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method == http.MethodHead {
-			w.Header().Set("ETag", `"safe"`)
-			w.Header().Set("Content-Disposition", `attachment; filename="../OllamaSetup.exe"`)
-			w.WriteHeader(http.StatusOK)
-			return
-		}
-		getAttempted.Store(true)
-		w.WriteHeader(http.StatusOK)
-	}))
-	defer server.Close()
-
-	updater := &Updater{}
-	err := updater.DownloadNewRelease(t.Context(), UpdateResponse{UpdateURL: server.URL + "/download"})
-	if err == nil || !strings.Contains(err.Error(), "unsafe update filename") {
-		t.Fatalf("expected unsafe filename error, got %v", err)
-	}
-	if getAttempted.Load() {
-		t.Fatal("download should not continue after unsafe filename")
-	}
-	if _, err := os.Stat(filepath.Join(filepath.Dir(UpdateStageDir), "OllamaSetup.exe")); err == nil {
-		t.Fatal("download escaped update stage dir")
-	}
-}
-
-func TestDownloadNewReleaseDoesNotUseRawETagAsPathComponent(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	oldInstaller := Installer
-	oldVerifyDownload := VerifyDownload
-	oldUpdateDownloaded := UpdateDownloaded
-	defer func() {
-		Installer = oldInstaller
-		VerifyDownload = oldVerifyDownload
-		UpdateDownloaded = oldUpdateDownloaded
-	}()
-	Installer = "OllamaSetup.exe"
-	UpdateDownloaded = false
-	VerifyDownload = func() error {
-		return nil
-	}
-
-	payload := []byte("payload")
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("ETag", `"../escaped"`)
-		w.WriteHeader(http.StatusOK)
-		if r.Method == http.MethodGet {
-			_, _ = w.Write(payload)
-		}
-	}))
-	defer server.Close()
-
-	updater := &Updater{}
-	if err := updater.DownloadNewRelease(t.Context(), UpdateResponse{UpdateURL: server.URL + "/download"}); err != nil {
-		t.Fatal(err)
-	}
-
-	if _, err := os.Stat(filepath.Join(filepath.Dir(UpdateStageDir), "escaped", Installer)); err == nil {
-		t.Fatal("download escaped update stage dir via etag")
-	}
-
-	entries, err := os.ReadDir(UpdateStageDir)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(entries) != 1 {
-		t.Fatalf("expected one staged update dir, got %d", len(entries))
-	}
-	stageFilename := filepath.Join(UpdateStageDir, entries[0].Name(), Installer)
-	got, err := os.ReadFile(stageFilename)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(got) != string(payload) {
-		t.Fatalf("unexpected staged payload %q", got)
-	}
-}
-
-func TestBackgroundCheckerSkipsAlreadyStagedETagDownload(t *testing.T) {
-	UpdateStageDir = t.TempDir()
-	oldInstaller := Installer
-	oldVerifyDownload := VerifyDownload
-	oldUpdateDownloaded := UpdateDownloaded
-	oldUpdateCheckInitialDelay := UpdateCheckInitialDelay
-	oldUpdateCheckInterval := UpdateCheckInterval
-	oldUpdateCheckURLBase := UpdateCheckURLBase
-	defer func() {
-		Installer = oldInstaller
-		VerifyDownload = oldVerifyDownload
-		UpdateDownloaded = oldUpdateDownloaded
-		UpdateCheckInitialDelay = oldUpdateCheckInitialDelay
-		UpdateCheckInterval = oldUpdateCheckInterval
-		UpdateCheckURLBase = oldUpdateCheckURLBase
-	}()
-	Installer = "OllamaSetup.exe"
-	UpdateDownloaded = false
-	UpdateCheckInitialDelay = time.Millisecond
-	UpdateCheckInterval = 5 * time.Millisecond
-
-	var verifyCount atomic.Int32
-	VerifyDownload = func() error {
-		verifyCount.Add(1)
-		return nil
-	}
-
-	headETag := `"old-update"`
-	getETag := `"download-response-etag"`
-	payload := []byte("payload")
-	var headCount atomic.Int32
-	var getCount atomic.Int32
-	var server *httptest.Server
-	server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/update.json":
-			w.Write([]byte(
-				fmt.Sprintf(`{"version": "9.9.9", "url": "%s"}`,
-					server.URL+"/9.9.9/"+Installer)))
-		case "/9.9.9/" + Installer:
-			w.Header().Set("Content-Disposition", `attachment; filename="OllamaSetup.exe"`)
-			switch r.Method {
-			case http.MethodHead:
-				etag := headETag
-				if getCount.Load() > 0 {
-					etag = getETag
-				}
-				w.Header().Set("ETag", etag)
-				headCount.Add(1)
-				w.WriteHeader(http.StatusOK)
-			case http.MethodGet:
-				w.Header().Set("ETag", getETag)
-				getCount.Add(1)
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write(payload)
-			default:
-				t.Errorf("unexpected request method %s", r.Method)
-				w.WriteHeader(http.StatusMethodNotAllowed)
-			}
-		default:
-			t.Errorf("unexpected request path %s", r.URL.Path)
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer server.Close()
-	UpdateCheckURLBase = server.URL + "/update.json"
-
-	updater := &Updater{Store: &store.Store{DBPath: filepath.Join(t.TempDir(), "test.db")}}
-	defer updater.Store.Close()
-	settings, err := updater.Store.Settings()
-	if err != nil {
-		t.Fatal(err)
-	}
-	settings.AutoUpdateEnabled = true
-	if err := updater.Store.SetSettings(settings); err != nil {
-		t.Fatal(err)
-	}
-
-	ctx, cancel := context.WithCancel(t.Context())
-	defer cancel()
-
-	callbacks := make(chan string, 4)
-	updater.StartBackgroundUpdaterChecker(ctx, func(ver string) error {
-		callbacks <- ver
-		return nil
-	})
-
-	for range 2 {
-		select {
-		case <-callbacks:
-		case <-time.After(5 * time.Second):
-			t.Fatal("timed out waiting for repeated update checks")
-		}
-	}
-	cancel()
-
-	stageFilename, err := updateStagePath(UpdateStageDir, getETag, Installer)
-	if err != nil {
-		t.Fatal(err)
-	}
-	got, err := os.ReadFile(stageFilename)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(got) != string(payload) {
-		t.Fatalf("unexpected staged payload %q", got)
-	}
-
-	if headCount.Load() < 2 {
-		t.Fatalf("HEAD count = %d, want at least 2", headCount.Load())
-	}
-	if getCount.Load() != 1 {
-		t.Fatalf("GET count = %d, want 1", getCount.Load())
-	}
-	if verifyCount.Load() != 1 {
-		t.Fatalf("verification count = %d, want 1", verifyCount.Load())
-	}
-	if !UpdateDownloaded {
-		t.Fatal("UpdateDownloaded should stay true for already staged update")
-	}
-}
-
 func TestBackgoundChecker(t *testing.T) {
 	UpdateStageDir = t.TempDir()
 	haveUpdate := false
@@ -1,7 +1,6 @@
 package updater

 import (
-	"crypto/x509"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -19,30 +18,6 @@ import (

 var runningInstaller string

-var (
-	crypt32              = windows.NewLazySystemDLL("crypt32.dll")
-	procCryptMsgGetParam = crypt32.NewProc("CryptMsgGetParam")
-	procCryptMsgClose    = crypt32.NewProc("CryptMsgClose")
-)
-
-const cmsgSignerInfoParam = 6
-
-type cmsgSignerInfo struct {
-	Version                 uint32
-	Issuer                  windows.CertNameBlob
-	SerialNumber            windows.CryptIntegerBlob
-	HashAlgorithm           windows.CryptAlgorithmIdentifier
-	HashEncryptionAlgorithm windows.CryptAlgorithmIdentifier
-	EncryptedHash           windows.CryptDataBlob
-	AuthAttrs               cryptAttributes
-	UnauthAttrs             cryptAttributes
-}
-
-type cryptAttributes struct {
-	Count      uint32
-	Attributes unsafe.Pointer
-}
-
 type OSVERSIONINFOEXW struct {
 	dwOSVersionInfoSize uint32
 	dwMajorVersion      uint32
@@ -124,12 +99,6 @@ func DoUpgrade(interactive bool) error {
 		return fmt.Errorf("failed to lookup downloads")
 	}

-	if err := VerifyDownload(); err != nil {
-		_ = os.Remove(bundle)
-		slog.Warn("verification failure", "bundle", bundle, "error", err)
-		return fmt.Errorf("staged update verification failed: %w", err)
-	}
-
 	// We move the installer to ensure we don't race with multiple apps starting in quick succession
 	if err := os.Rename(bundle, runningInstaller); err != nil {
 		return fmt.Errorf("unable to rename %s -> %s : %w", bundle, runningInstaller, err)
@@ -215,150 +184,6 @@ func DoPostUpgradeCleanup() error {
 }

 func verifyDownload() error {
-	bundle := getStagedUpdate()
-	if bundle == "" {
-		return fmt.Errorf("failed to lookup downloads")
-	}
-	slog.Debug("verifying update", "bundle", bundle)
-
-	if err := verifyWindowsInstallerSignature(bundle); err != nil {
-		return fmt.Errorf("signature verification failed: %w", err)
-	}
-	return nil
-}
-
-func verifyWindowsInstallerSignature(filename string) error {
-	filename16, err := windows.UTF16PtrFromString(filename)
-	if err != nil {
-		return err
-	}
-
-	data := &windows.WinTrustData{
-		Size:             uint32(unsafe.Sizeof(windows.WinTrustData{})),
-		UIChoice:         windows.WTD_UI_NONE,
-		RevocationChecks: windows.WTD_REVOKE_WHOLECHAIN,
-		UnionChoice:      windows.WTD_CHOICE_FILE,
-		StateAction:      windows.WTD_STATEACTION_VERIFY,
-		UIContext:        windows.WTD_UICONTEXT_INSTALL,
-		FileOrCatalogOrBlobOrSgnrOrCert: unsafe.Pointer(&windows.WinTrustFileInfo{
-			Size:     uint32(unsafe.Sizeof(windows.WinTrustFileInfo{})),
-			FilePath: filename16,
-		}),
-	}
-
-	verifyErr := windows.WinVerifyTrustEx(windows.InvalidHWND, &windows.WINTRUST_ACTION_GENERIC_VERIFY_V2, data)
-	data.StateAction = windows.WTD_STATEACTION_CLOSE
-	closeErr := windows.WinVerifyTrustEx(windows.InvalidHWND, &windows.WINTRUST_ACTION_GENERIC_VERIFY_V2, data)
-	if verifyErr != nil {
-		return verifyErr
-	}
-	if closeErr != nil {
-		return fmt.Errorf("close WinVerifyTrust state: %w", closeErr)
-	}
-
-	subject, err := windowsInstallerSignerSubject(filename)
-	if err != nil {
-		return err
-	}
-	slog.Debug("verified update signature", "subject", subject)
-	return nil
-}
-
-func windowsInstallerSignerSubject(filename string) (string, error) {
-	filename16, err := windows.UTF16PtrFromString(filename)
-	if err != nil {
-		return "", err
-	}
-
-	var certStore windows.Handle
-	var msg windows.Handle
-	if err := windows.CryptQueryObject(
-		windows.CERT_QUERY_OBJECT_FILE,
-		unsafe.Pointer(filename16),
-		windows.CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
-		windows.CERT_QUERY_FORMAT_FLAG_BINARY,
-		0,
-		nil,
-		nil,
-		nil,
-		&certStore,
-		&msg,
-		nil,
-	); err != nil {
-		return "", err
-	}
-	defer windows.CertCloseStore(certStore, 0) //nolint:errcheck
-	defer cryptMsgClose(msg)                   //nolint:errcheck
-
-	var signerInfoSize uint32
-	if err := cryptMsgGetParam(msg, cmsgSignerInfoParam, 0, nil, &signerInfoSize); err != nil {
-		return "", err
-	}
-	if signerInfoSize == 0 {
-		return "", fmt.Errorf("missing signer info")
-	}
-
-	signerInfoBuf := make([]byte, signerInfoSize)
-	if err := cryptMsgGetParam(msg, cmsgSignerInfoParam, 0, unsafe.Pointer(&signerInfoBuf[0]), &signerInfoSize); err != nil {
-		return "", err
-	}
-	signerInfo := (*cmsgSignerInfo)(unsafe.Pointer(&signerInfoBuf[0]))
-	certInfo := windows.CertInfo{
-		Issuer:       signerInfo.Issuer,
-		SerialNumber: signerInfo.SerialNumber,
-	}
-
-	cert, err := windows.CertFindCertificateInStore(
-		certStore,
-		windows.X509_ASN_ENCODING|windows.PKCS_7_ASN_ENCODING,
-		0,
-		windows.CERT_FIND_SUBJECT_CERT,
-		unsafe.Pointer(&certInfo),
-		nil,
-	)
-	if err != nil {
-		return "", err
-	}
-	defer windows.CertFreeCertificateContext(cert) //nolint:errcheck
-
-	parsed, err := x509.ParseCertificate(unsafe.Slice(cert.EncodedCert, cert.Length))
-	if err != nil {
-		return "", err
-	}
-
-	for _, org := range parsed.Subject.Organization {
-		if org == "Ollama Inc." {
-			return parsed.Subject.String(), nil
-		}
-	}
-	return "", fmt.Errorf("unexpected signer: %s", parsed.Subject.String())
-}
-
-func cryptMsgGetParam(msg windows.Handle, paramType, index uint32, data unsafe.Pointer, size *uint32) error {
-	r1, _, e1 := procCryptMsgGetParam.Call(
-		uintptr(msg),
-		uintptr(paramType),
-		uintptr(index),
-		uintptr(data),
-		uintptr(unsafe.Pointer(size)),
-	)
-	if r1 == 0 {
-		if e1 != syscall.Errno(0) {
-			return e1
-		}
-		return syscall.EINVAL
-	}
-	return nil
-}
-
-func cryptMsgClose(msg windows.Handle) error {
-	r1, _, e1 := procCryptMsgClose.Call(uintptr(msg))
-	if r1 == 0 {
-		if e1 != syscall.Errno(0) {
-			return e1
-		}
-		return syscall.EINVAL
-	}
 	return nil
 }

@@ -1,85 +1,13 @@
-//go:build windows
+//go:build windows || darwin

 package updater

 import (
 	"log/slog"
-	"os"
-	"path/filepath"
-	"strings"
 	"testing"
 )

-func TestVerifyDownloadRejectsUnsignedWindowsInstaller(t *testing.T) {
-	oldUpdateStageDir := UpdateStageDir
-	defer func() {
-		UpdateStageDir = oldUpdateStageDir
-	}()
-
-	t.Setenv("LOCALAPPDATA", t.TempDir())
-	UpdateStageDir = t.TempDir()
-	bundle := filepath.Join(UpdateStageDir, "etag", "OllamaSetup.exe")
-	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(bundle, []byte("not a signed installer"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	err := verifyDownload()
-	if err == nil || !strings.Contains(err.Error(), "signature verification failed") {
-		t.Fatalf("expected signature verification failure, got %v", err)
-	}
-}
-
-func TestDoUpgradeAtStartupRejectsUnsignedWindowsInstaller(t *testing.T) {
-	oldUpdateStageDir := UpdateStageDir
-	oldRunningInstaller := runningInstaller
-	oldUpgradeLogFile := UpgradeLogFile
-	oldUpgradeMarkerFile := UpgradeMarkerFile
-	oldVerifyDownload := VerifyDownload
-	defer func() {
-		UpdateStageDir = oldUpdateStageDir
-		runningInstaller = oldRunningInstaller
-		UpgradeLogFile = oldUpgradeLogFile
-		UpgradeMarkerFile = oldUpgradeMarkerFile
-		VerifyDownload = oldVerifyDownload
-	}()
-
-	t.Setenv("LOCALAPPDATA", t.TempDir())
-	UpdateStageDir = t.TempDir()
-	runDir := t.TempDir()
-	runningInstaller = filepath.Join(runDir, "OllamaSetup.exe")
-	UpgradeLogFile = filepath.Join(runDir, "upgrade.log")
-	UpgradeMarkerFile = filepath.Join(runDir, "upgraded")
-	VerifyDownload = verifyDownload
-
-	bundle := filepath.Join(UpdateStageDir, "etag", "OllamaSetup.exe")
-	if err := os.MkdirAll(filepath.Dir(bundle), 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(bundle, []byte("not a signed installer"), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	err := DoUpgradeAtStartup()
-	if err == nil || !strings.Contains(err.Error(), "signature verification failed") {
-		t.Fatalf("expected signature verification failure, got %v", err)
-	}
-	if _, err := os.Stat(runningInstaller); !os.IsNotExist(err) {
-		t.Fatalf("unsigned installer was moved before verification failed: %v", err)
-	}
-	if _, err := os.Stat(bundle); !os.IsNotExist(err) {
-		t.Fatalf("unsigned staged installer was not removed after verification failure: %v", err)
-	}
-}
-
 func TestIsInstallerRunning(t *testing.T) {
-	oldInstaller := Installer
-	defer func() {
-		Installer = oldInstaller
-	}()
-
 	slog.SetLogLoggerLevel(slog.LevelDebug)
 	Installer = "go.exe"
 	if !isInstallerRunning() {
@@ -1,31 +1,27 @@
 Ollama Benchmark Tool
 ---------------------

-A Go-based command-line tool for benchmarking Ollama models with configurable parameters, warmup phases, TTFT tracking, VRAM monitoring, and benchstat/CSV output.
+A Go-based command-line tool for benchmarking Ollama models with configurable parameters and multiple output formats.

 ## Features

 * Benchmark multiple models in a single run
 * Support for both text and image prompts
 * Configurable generation parameters (temperature, max tokens, seed, etc.)
- * Warmup phase before timed epochs to stabilize measurements
- * Time-to-first-token (TTFT) tracking per epoch
- * Model metadata display (parameter size, quantization level, family)
- * VRAM and CPU memory usage tracking via running process info
- * Controlled prompt token length for reproducible benchmarks
- * Benchstat and CSV output formats
+ * Supports benchstat and CSV output formats
+ * Detailed performance metrics (prefill, generate, load, total durations)

 ## Building from Source

 ```
-go build -o ollama-bench ./cmd/bench
-./ollama-bench -model gemma3 -epochs 6 -format csv
+go build -o ollama-bench bench.go
+./ollama-bench -model gpt-oss:20b -epochs 6 -format csv
 ```

 Using Go Run (without building)

 ```
-go run ./cmd/bench -model gemma3 -epochs 3
+go run bench.go -model gpt-oss:20b -epochs 3
 ```

 ## Usage
@@ -49,16 +45,10 @@ benchstat -col /name gemma.bench
 ./ollama-bench -model qwen3-vl -image photo.jpg -epochs 6 -max-tokens 100 -p "Describe this image"
 ```

-### Controlled Prompt Length
-
-```
-./ollama-bench -model gemma3 -epochs 6 -prompt-tokens 512
-```
-
 ### Advanced Example

 ```
-./ollama-bench -model llama3 -epochs 10 -temperature 0.7 -max-tokens 500 -seed 42 -warmup 2 -format csv -output results.csv
+./ollama-bench -model llama3 -epochs 10 -temperature 0.7 -max-tokens 500 -seed 42 -format csv -output results.csv
 ```

 ## Command Line Options
@@ -66,48 +56,41 @@ benchstat -col /name gemma.bench
 | Option  	| Description | Default |
 |----------|-------------|---------|
 | -model	| Comma-separated list of models to benchmark	| (required)		|
-| -epochs	| Number of iterations per model		| 6			|
-| -max-tokens	| Maximum tokens for model response		| 200			|
+| -epochs	| Number of iterations per model		| 1			|
+| -max-tokens	| Maximum tokens for model response		| 0 (unlimited)		|
 | -temperature	| Temperature parameter				| 0.0			|
 | -seed		| Random seed					| 0 (random)		|
 | -timeout	| Timeout in seconds				| 300			|
-| -p		| Prompt text					| (default story prompt)	|
+| -p		| Prompt text					| "Write a long story."	|
 | -image	| Image file to include in prompt		| 			|
 | -k		| Keep-alive duration in seconds		| 0			|
 | -format	| Output format (benchstat, csv)		| benchstat		|
 | -output	| Output file for results			| "" (stdout)		|
-| -warmup	| Number of warmup requests before timing	| 1			|
-| -prompt-tokens	| Generate prompt targeting ~N tokens (0 = use -p)	| 0		|
 | -v		| Verbose mode					| false			|
 | -debug	| Show debug information			| false			|

 ## Output Formats

-### Benchstat Format (default)
-
-Compatible with Go's benchstat tool for statistical analysis. Uses one value/unit pair per line, standard `ns/op` for timing metrics, and `ns/token` for throughput. Each epoch produces one set of lines -- benchstat aggregates across repeated runs to compute statistics.
+### Markdown Format

+The default markdown format is suitable for copying and pasting into a GitHub issue and will look like:
 ```
-# Model: gemma3 | Params: 4.3B | Quant: Q4_K_M | Family: gemma3 | Size: 4080218931 | VRAM: 4080218931
-BenchmarkModel/name=gemma3/step=prefill 1 78125.00 ns/token 12800.00 token/sec
-BenchmarkModel/name=gemma3/step=generate 1 19531.25 ns/token 51200.00 token/sec
-BenchmarkModel/name=gemma3/step=ttft 1 45123000 ns/op
-BenchmarkModel/name=gemma3/step=load 1 1500000000 ns/op
-BenchmarkModel/name=gemma3/step=total 1 2861047625 ns/op
+ Model | Step | Count | Duration | nsPerToken | tokensPerSec |
+|-------|------|-------|----------|------------|--------------|
+| gpt-oss:20b | prefill | 124 | 30.006458ms | 241987.56 | 4132.44 |
+| gpt-oss:20b | generate | 200 | 2.646843954s | 13234219.77 | 75.56 |
+| gpt-oss:20b | load | 1 | 121.674208ms | - | - |
+| gpt-oss:20b | total | 1 | 2.861047625s | - | - |
 ```

-Use with benchstat:
-```
-./ollama-bench -model gemma3 -epochs 6 > gemma3.bench
-benchstat -col /step gemma3.bench
-```
+### Benchstat Format
+
+Compatible with Go's benchstat tool for statistical analysis:

-Compare two runs:
 ```
-./ollama-bench -model gemma3 -epochs 6 > before.bench
-# ... make changes ...
-./ollama-bench -model gemma3 -epochs 6 > after.bench
-benchstat before.bench after.bench
+BenchmarkModel/name=gpt-oss:20b/step=prefill 128 78125.00 ns/token 12800.00 token/sec
+BenchmarkModel/name=gpt-oss:20b/step=generate 512 19531.25 ns/token 51200.00 token/sec
+BenchmarkModel/name=gpt-oss:20b/step=load 1 1500000000 ns/request
 ```

 ### CSV Format
@@ -116,28 +99,17 @@ Machine-readable comma-separated values:

 ```
 NAME,STEP,COUNT,NS_PER_COUNT,TOKEN_PER_SEC
-# Model: gemma3 | Params: 4.3B | Quant: Q4_K_M | Family: gemma3 | Size: 4080218931 | VRAM: 4080218931
-gemma3,prefill,128,78125.00,12800.00
-gemma3,generate,512,19531.25,51200.00
-gemma3,ttft,1,45123000,0
-gemma3,load,1,1500000000,0
-gemma3,total,1,2861047625,0
+gpt-oss:20b,prefill,128,78125.00,12800.00
+gpt-oss:20b,generate,512,19531.25,51200.00
+gpt-oss:20b,load,1,1500000000,0
 ```

 ## Metrics Explained

-The tool reports the following metrics for each epoch:
+The tool reports four types of metrics for each model:

- * **prefill**: Time spent processing the prompt (ns/token)
- * **generate**: Time spent generating the response (ns/token)
- * **ttft**: Time to first token -- latency from request start to first response content
- * **load**: Model loading time (one-time cost)
- * **total**: Total request duration
+ * prefill: Time spent processing the prompt
+ * generate: Time spent generating the response
+ * load: Model loading time (one-time cost)
+ * total: Total request duration

-Additionally, the model info comment line (displayed once per model before epochs) includes:
-
- * **Params**: Model parameter count (e.g., 4.3B)
- * **Quant**: Quantization level (e.g., Q4_K_M)
- * **Family**: Model family (e.g., gemma3)
- * **Size**: Total model memory in bytes
- * **VRAM**: GPU memory used by the loaded model (when Size > VRAM, the difference is CPU spill)
@@ -17,22 +17,19 @@ import (
 )

 type flagOptions struct {
-	models       *string
-	epochs       *int
-	maxTokens    *int
-	temperature  *float64
-	seed         *int
-	timeout      *int
-	prompt       *string
-	imageFile    *string
-	keepAlive    *float64
-	format       *string
-	outputFile   *string
-	debug        *bool
-	verbose      *bool
-	warmup       *int
-	promptTokens *int
-	numCtx       *int
+	models      *string
+	epochs      *int
+	maxTokens   *int
+	temperature *float64
+	seed        *int
+	timeout     *int
+	prompt      *string
+	imageFile   *string
+	keepAlive   *float64
+	format      *string
+	outputFile  *string
+	debug       *bool
+	verbose     *bool
 }

 type Metrics struct {
@@ -42,203 +39,48 @@ type Metrics struct {
 	Duration time.Duration
 }

-type ModelInfo struct {
-	Name              string
-	ParameterSize     string
-	QuantizationLevel string
-	Family            string
-	SizeBytes         int64
-	VRAMBytes         int64
-	NumCtx            int64
-}
+var once sync.Once

 const DefaultPrompt = `Please write a descriptive story about a llama named Alonso who grows up to be President of the Land of Llamas. Include details about Alonso's childhood, adolescent years, and how he grew up to be a political mover and shaker. Write the story with a sense of whimsy.`

-// Word list for generating prompts targeting a specific token count.
-var promptWordList = []string{
-	"the", "quick", "brown", "fox", "jumps", "over", "lazy", "dog",
-	"a", "bright", "sunny", "day", "in", "the", "meadow", "where",
-	"flowers", "bloom", "and", "birds", "sing", "their", "morning",
-	"songs", "while", "gentle", "breeze", "carries", "sweet", "scent",
-	"of", "pine", "trees", "across", "rolling", "hills", "toward",
-	"distant", "mountains", "covered", "with", "fresh", "snow",
-	"beneath", "clear", "blue", "sky", "children", "play", "near",
-	"old", "stone", "bridge", "that", "crosses", "winding", "river",
-}
-
-// tokensPerWord is the calibrated ratio of tokens to words for the current model.
-// Initialized with a heuristic, then updated during warmup based on actual tokenization.
-var tokensPerWord = 1.3
-
-func generatePromptForTokenCount(targetTokens int, epoch int) string {
-	targetWords := int(float64(targetTokens) / tokensPerWord)
-	if targetWords < 1 {
-		targetWords = 1
-	}
-
-	// Vary the starting offset by epoch to defeat KV cache prefix matching
-	offset := epoch * 7 // stride by a prime to get good distribution
-	n := len(promptWordList)
-	words := make([]string, targetWords)
-	for i := range words {
-		words[i] = promptWordList[((i+offset)%n+n)%n]
-	}
-	return strings.Join(words, " ")
-}
-
-// calibratePromptTokens adjusts tokensPerWord based on actual tokenization from a warmup run.
-func calibratePromptTokens(targetTokens, actualTokens, wordCount int) {
-	if actualTokens <= 0 || wordCount <= 0 {
-		return
-	}
-	tokensPerWord = float64(actualTokens) / float64(wordCount)
-	newWords := int(float64(targetTokens) / tokensPerWord)
-	fmt.Fprintf(os.Stderr, "bench: calibrated %.2f tokens/word (target=%d, got=%d, words=%d → %d)\n",
-		tokensPerWord, targetTokens, actualTokens, wordCount, newWords)
-}
-
-func buildGenerateRequest(model string, fOpt flagOptions, imgData api.ImageData, epoch int) *api.GenerateRequest {
-	options := make(map[string]interface{})
-	if *fOpt.maxTokens > 0 {
-		options["num_predict"] = *fOpt.maxTokens
-	}
-	options["temperature"] = *fOpt.temperature
-	if fOpt.seed != nil && *fOpt.seed > 0 {
-		options["seed"] = *fOpt.seed
-	}
-	if fOpt.numCtx != nil && *fOpt.numCtx > 0 {
-		options["num_ctx"] = *fOpt.numCtx
-	}
-
-	var keepAliveDuration *api.Duration
-	if *fOpt.keepAlive > 0 {
-		duration := api.Duration{Duration: time.Duration(*fOpt.keepAlive * float64(time.Second))}
-		keepAliveDuration = &duration
-	}
-
-	prompt := *fOpt.prompt
-	if *fOpt.promptTokens > 0 {
-		prompt = generatePromptForTokenCount(*fOpt.promptTokens, epoch)
-	} else {
-		// Vary the prompt per epoch to defeat KV cache prefix matching
-		prompt = fmt.Sprintf("[%d] %s", epoch, prompt)
-	}
-
-	req := &api.GenerateRequest{
-		Model:     model,
-		Prompt:    prompt,
-		Raw:       true,
-		Options:   options,
-		KeepAlive: keepAliveDuration,
-	}
-
-	if imgData != nil {
-		req.Images = []api.ImageData{imgData}
-	}
-
-	return req
-}
-
-func fetchModelInfo(ctx context.Context, client *api.Client, model string) ModelInfo {
-	info := ModelInfo{Name: model}
-	resp, err := client.Show(ctx, &api.ShowRequest{Model: model})
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "WARNING: Could not fetch model info for '%s': %v\n", model, err)
-		return info
-	}
-	info.ParameterSize = resp.Details.ParameterSize
-	info.QuantizationLevel = resp.Details.QuantizationLevel
-	info.Family = resp.Details.Family
-	return info
-}
-
-func fetchMemoryUsage(ctx context.Context, client *api.Client, model string) (size, vram int64) {
-	resp, err := client.ListRunning(ctx)
-	if err != nil {
-		if debug := os.Getenv("OLLAMA_DEBUG"); debug != "" {
-			fmt.Fprintf(os.Stderr, "WARNING: Could not fetch memory usage: %v\n", err)
-		}
-		return 0, 0
-	}
-	for _, m := range resp.Models {
-		if m.Name == model || m.Model == model {
-			return m.Size, m.SizeVRAM
-		}
-	}
-	for _, m := range resp.Models {
-		if strings.HasPrefix(m.Name, model) || strings.HasPrefix(m.Model, model) {
-			return m.Size, m.SizeVRAM
-		}
-	}
-	return 0, 0
-}
-
-func fetchContextLength(ctx context.Context, client *api.Client, model string) int64 {
-	resp, err := client.ListRunning(ctx)
-	if err != nil {
-		return 0
-	}
-	for _, m := range resp.Models {
-		if m.Name == model || m.Model == model || strings.HasPrefix(m.Name, model) || strings.HasPrefix(m.Model, model) {
-			return int64(m.ContextLength)
-		}
-	}
-	return 0
-}
-
-func outputFormatHeader(w io.Writer, format string, verbose bool) {
-	switch format {
-	case "benchstat":
-		if verbose {
-			fmt.Fprintf(w, "goos: %s\n", runtime.GOOS)
-			fmt.Fprintf(w, "goarch: %s\n", runtime.GOARCH)
-		}
-	case "csv":
-		headings := []string{"NAME", "STEP", "COUNT", "NS_PER_COUNT", "TOKEN_PER_SEC"}
-		fmt.Fprintln(w, strings.Join(headings, ","))
-	}
-}
-
-func outputModelInfo(w io.Writer, format string, info ModelInfo) {
-	params := cmp.Or(info.ParameterSize, "unknown")
-	quant := cmp.Or(info.QuantizationLevel, "unknown")
-	family := cmp.Or(info.Family, "unknown")
-
-	memStr := ""
-	if info.SizeBytes > 0 {
-		memStr = fmt.Sprintf(" | Size: %d | VRAM: %d", info.SizeBytes, info.VRAMBytes)
-	}
-	ctxStr := ""
-	if info.NumCtx > 0 {
-		ctxStr = fmt.Sprintf(" | NumCtx: %d", info.NumCtx)
-	}
-	fmt.Fprintf(w, "# Model: %s | Params: %s | Quant: %s | Family: %s%s%s\n",
-		info.Name, params, quant, family, memStr, ctxStr)
-}
-
 func OutputMetrics(w io.Writer, format string, metrics []Metrics, verbose bool) {
 	switch format {
 	case "benchstat":
+		if verbose {
+			printHeader := func() {
+				fmt.Fprintf(w, "sysname: %s\n", runtime.GOOS)
+				fmt.Fprintf(w, "machine: %s\n", runtime.GOARCH)
+			}
+			once.Do(printHeader)
+		}
 		for _, m := range metrics {
 			if m.Step == "generate" || m.Step == "prefill" {
 				if m.Count > 0 {
 					nsPerToken := float64(m.Duration.Nanoseconds()) / float64(m.Count)
 					tokensPerSec := float64(m.Count) / (float64(m.Duration.Nanoseconds()) + 1e-12) * 1e9
-					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 %.2f ns/token %.2f token/sec\n",
-						m.Model, m.Step, nsPerToken, tokensPerSec)
+
+					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s %d %.2f ns/token %.2f token/sec\n",
+						m.Model, m.Step, m.Count, nsPerToken, tokensPerSec)
 				} else {
-					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 0 ns/token 0 token/sec\n",
-						m.Model, m.Step)
+					fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s %d 0 ns/token 0 token/sec\n",
+						m.Model, m.Step, m.Count)
 				}
-			} else if m.Step == "ttft" {
-				fmt.Fprintf(w, "BenchmarkModel/name=%s/step=ttft 1 %d ns/op\n",
-					m.Model, m.Duration.Nanoseconds())
 			} else {
-				fmt.Fprintf(w, "BenchmarkModel/name=%s/step=%s 1 %d ns/op\n",
-					m.Model, m.Step, m.Duration.Nanoseconds())
+				var suffix string
+				if m.Step == "load" {
+					suffix = "/step=load"
+				}
+				fmt.Fprintf(w, "BenchmarkModel/name=%s%s 1 %d ns/request\n",
+					m.Model, suffix, m.Duration.Nanoseconds())
 			}
 		}
 	case "csv":
+		printHeader := func() {
+			headings := []string{"NAME", "STEP", "COUNT", "NS_PER_COUNT", "TOKEN_PER_SEC"}
+			fmt.Fprintln(w, strings.Join(headings, ","))
+		}
+		once.Do(printHeader)
+
 		for _, m := range metrics {
 			if m.Step == "generate" || m.Step == "prefill" {
 				var nsPerToken float64
@@ -252,14 +94,39 @@ func OutputMetrics(w io.Writer, format string, metrics []Metrics, verbose bool)
 				fmt.Fprintf(w, "%s,%s,1,%d,0\n", m.Model, m.Step, m.Duration.Nanoseconds())
 			}
 		}
+	case "markdown":
+		printHeader := func() {
+			fmt.Fprintln(w, "| Model | Step | Count | Duration | nsPerToken | tokensPerSec |")
+			fmt.Fprintln(w, "|-------|------|-------|----------|------------|--------------|")
+		}
+		once.Do(printHeader)
+
+		for _, m := range metrics {
+			var nsPerToken, tokensPerSec float64
+			var nsPerTokenStr, tokensPerSecStr string
+
+			if m.Step == "generate" || m.Step == "prefill" {
+				nsPerToken = float64(m.Duration.Nanoseconds()) / float64(m.Count)
+				tokensPerSec = float64(m.Count) / (float64(m.Duration.Nanoseconds()) + 1e-12) * 1e9
+				nsPerTokenStr = fmt.Sprintf("%.2f", nsPerToken)
+				tokensPerSecStr = fmt.Sprintf("%.2f", tokensPerSec)
+			} else {
+				nsPerTokenStr = "-"
+				tokensPerSecStr = "-"
+			}
+
+			fmt.Fprintf(w, "| %s | %s | %d | %v | %s | %s |\n",
+				m.Model, m.Step, m.Count, m.Duration, nsPerTokenStr, tokensPerSecStr)
+		}
 	default:
 		fmt.Fprintf(os.Stderr, "Unknown output format '%s'\n", format)
 	}
 }

-func BenchmarkModel(fOpt flagOptions) error {
+func BenchmarkChat(fOpt flagOptions) error {
 	models := strings.Split(*fOpt.models, ",")

+	// todo - add multi-image support
 	var imgData api.ImageData
 	var err error
 	if *fOpt.imageFile != "" {
@@ -291,141 +158,71 @@ func BenchmarkModel(fOpt flagOptions) error {
 		out = f
 	}

-	outputFormatHeader(out, *fOpt.format, *fOpt.verbose)
-
-	// Log prompt-tokens info in debug mode
-	if *fOpt.debug && *fOpt.promptTokens > 0 {
-		prompt := generatePromptForTokenCount(*fOpt.promptTokens, 0)
-		wordCount := len(strings.Fields(prompt))
-		fmt.Fprintf(os.Stderr, "Generated prompt targeting ~%d tokens (%d words, varied per epoch)\n", *fOpt.promptTokens, wordCount)
-	}
-
 	for _, model := range models {
-		// Fetch model info
-		infoCtx, infoCancel := context.WithTimeout(context.Background(), 10*time.Second)
-		info := fetchModelInfo(infoCtx, client, model)
-		infoCancel()
+		for range *fOpt.epochs {
+			options := make(map[string]interface{})
+			if *fOpt.maxTokens > 0 {
+				options["num_predict"] = *fOpt.maxTokens
+			}
+			options["temperature"] = *fOpt.temperature
+			if fOpt.seed != nil && *fOpt.seed > 0 {
+				options["seed"] = *fOpt.seed
+			}
+
+			var keepAliveDuration *api.Duration
+			if *fOpt.keepAlive > 0 {
+				duration := api.Duration{Duration: time.Duration(*fOpt.keepAlive * float64(time.Second))}
+				keepAliveDuration = &duration
+			}
+
+			req := &api.ChatRequest{
+				Model: model,
+				Messages: []api.Message{
+					{
+						Role:    "user",
+						Content: *fOpt.prompt,
+					},
+				},
+				Options:   options,
+				KeepAlive: keepAliveDuration,
+			}
+
+			if imgData != nil {
+				req.Messages[0].Images = []api.ImageData{imgData}
+			}
+
+			var responseMetrics *api.Metrics

-		// Warmup phase (uses negative epoch numbers to avoid colliding with timed epochs)
-		for i := range *fOpt.warmup {
-			req := buildGenerateRequest(model, fOpt, imgData, -(i + 1))
 			ctx, cancel := context.WithTimeout(context.Background(), time.Duration(*fOpt.timeout)*time.Second)
+			defer cancel()
+
+			err = client.Chat(ctx, req, func(resp api.ChatResponse) error {
+				if *fOpt.debug {
+					fmt.Fprintf(os.Stderr, "%s", cmp.Or(resp.Message.Thinking, resp.Message.Content))
+				}

-			var warmupMetrics *api.Metrics
-			err = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
 				if resp.Done {
-					warmupMetrics = &resp.Metrics
+					responseMetrics = &resp.Metrics
 				}
 				return nil
 			})
-			cancel()
+
+			if *fOpt.debug {
+				fmt.Fprintln(os.Stderr)
+			}

 			if err != nil {
-				fmt.Fprintf(os.Stderr, "WARNING: Warmup %d/%d for %s failed: %v\n", i+1, *fOpt.warmup, model, err)
-			} else {
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "Warmup %d/%d for %s complete\n", i+1, *fOpt.warmup, model)
+				if ctx.Err() == context.DeadlineExceeded {
+					fmt.Fprintf(os.Stderr, "ERROR: Chat request timed out with model '%s' after %vs\n", model, 1)
+					continue
 				}
-				// Calibrate prompt token count on last warmup run
-				if i == *fOpt.warmup-1 && *fOpt.promptTokens > 0 && warmupMetrics != nil {
-					prompt := generatePromptForTokenCount(*fOpt.promptTokens, -(i + 1))
-					wordCount := len(strings.Fields(prompt))
-					calibratePromptTokens(*fOpt.promptTokens, warmupMetrics.PromptEvalCount, wordCount)
-				}
-			}
-		}
-
-		// Fetch memory/context info once after warmup (model is loaded and stable)
-		memCtx, memCancel := context.WithTimeout(context.Background(), 5*time.Second)
-		info.SizeBytes, info.VRAMBytes = fetchMemoryUsage(memCtx, client, model)
-		if fOpt.numCtx != nil && *fOpt.numCtx > 0 {
-			info.NumCtx = int64(*fOpt.numCtx)
-		} else {
-			info.NumCtx = fetchContextLength(memCtx, client, model)
-		}
-		memCancel()
-
-		outputModelInfo(out, *fOpt.format, info)
-
-		// Timed epoch loop
-		shortCount := 0
-		for epoch := range *fOpt.epochs {
-			var responseMetrics *api.Metrics
-			var ttft time.Duration
-			short := false
-
-			// Retry loop: if the model hits a stop token before max-tokens,
-			// retry with a different prompt (up to maxRetries times).
-			const maxRetries = 3
-			for attempt := range maxRetries + 1 {
-				responseMetrics = nil
-				ttft = 0
-				var ttftOnce sync.Once
-
-				req := buildGenerateRequest(model, fOpt, imgData, epoch+attempt*1000)
-				requestStart := time.Now()
-
-				ctx, cancel := context.WithTimeout(context.Background(), time.Duration(*fOpt.timeout)*time.Second)
-
-				err = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
-					if *fOpt.debug {
-						fmt.Fprintf(os.Stderr, "%s", cmp.Or(resp.Thinking, resp.Response))
-					}
-
-					// Capture TTFT on first content
-					ttftOnce.Do(func() {
-						if resp.Response != "" || resp.Thinking != "" {
-							ttft = time.Since(requestStart)
-						}
-					})
-
-					if resp.Done {
-						responseMetrics = &resp.Metrics
-					}
-					return nil
-				})
-				cancel()
-
-				if *fOpt.debug {
-					fmt.Fprintln(os.Stderr)
-				}
-
-				if err != nil {
-					if ctx.Err() == context.DeadlineExceeded {
-						fmt.Fprintf(os.Stderr, "ERROR: Request timed out with model '%s' after %vs\n", model, *fOpt.timeout)
-					} else {
-						fmt.Fprintf(os.Stderr, "ERROR: Couldn't generate with model '%s': %v\n", model, err)
-					}
-					break
-				}
-
-				if responseMetrics == nil {
-					fmt.Fprintf(os.Stderr, "ERROR: No metrics received for model '%s'\n", model)
-					break
-				}
-
-				// Check if the response was shorter than requested
-				short = *fOpt.maxTokens > 0 && responseMetrics.EvalCount < *fOpt.maxTokens
-				if !short || attempt == maxRetries {
-					break
-				}
-
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "Short response (%d/%d tokens), retrying with different prompt (attempt %d/%d)\n",
-						responseMetrics.EvalCount, *fOpt.maxTokens, attempt+1, maxRetries)
-				}
-			}
-
-			if err != nil || responseMetrics == nil {
+				fmt.Fprintf(os.Stderr, "ERROR: Couldn't chat with model '%s': %v\n", model, err)
 				continue
 			}

-			if short {
-				shortCount++
-				if *fOpt.debug {
-					fmt.Fprintf(os.Stderr, "WARNING: Short response (%d/%d tokens) after %d retries for epoch %d\n",
-						responseMetrics.EvalCount, *fOpt.maxTokens, maxRetries, epoch+1)
-				}
+			if responseMetrics == nil {
+				fmt.Fprintf(os.Stderr, "ERROR: No metrics received for model '%s'\n", model)
+				continue
 			}

 			metrics := []Metrics{
@@ -441,12 +238,6 @@ func BenchmarkModel(fOpt flagOptions) error {
 					Count:    responseMetrics.EvalCount,
 					Duration: responseMetrics.EvalDuration,
 				},
-				{
-					Model:    model,
-					Step:     "ttft",
-					Count:    1,
-					Duration: ttft,
-				},
 				{
 					Model:    model,
 					Step:     "load",
@@ -463,42 +254,15 @@ func BenchmarkModel(fOpt flagOptions) error {

 			OutputMetrics(out, *fOpt.format, metrics, *fOpt.verbose)

-			if *fOpt.debug && *fOpt.promptTokens > 0 {
-				fmt.Fprintf(os.Stderr, "Generated prompt targeting ~%d tokens (actual: %d)\n",
-					*fOpt.promptTokens, responseMetrics.PromptEvalCount)
-			}
-
 			if *fOpt.keepAlive > 0 {
 				time.Sleep(time.Duration(*fOpt.keepAlive*float64(time.Second)) + 200*time.Millisecond)
 			}
 		}
-
-		if shortCount > 0 {
-			fmt.Fprintf(os.Stderr, "WARNING: %d/%d epochs for '%s' had short responses (<%d tokens). Generation metrics may be unreliable.\n",
-				shortCount, *fOpt.epochs, model, *fOpt.maxTokens)
-		}
-
-		// Unload model before moving to the next one
-		unloadModel(client, model, *fOpt.timeout)
 	}

 	return nil
 }

-func unloadModel(client *api.Client, model string, timeout int) {
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
-	defer cancel()
-
-	zero := api.Duration{Duration: 0}
-	req := &api.GenerateRequest{
-		Model:     model,
-		KeepAlive: &zero,
-	}
-	_ = client.Generate(ctx, req, func(resp api.GenerateResponse) error {
-		return nil
-	})
-}
-
 func readImage(filePath string) (api.ImageData, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -516,22 +280,19 @@ func readImage(filePath string) (api.ImageData, error) {

 func main() {
 	fOpt := flagOptions{
-		models:       flag.String("model", "", "Model to benchmark"),
-		epochs:       flag.Int("epochs", 6, "Number of epochs (iterations) per model"),
-		maxTokens:    flag.Int("max-tokens", 200, "Maximum tokens for model response"),
-		temperature:  flag.Float64("temperature", 0, "Temperature parameter"),
-		seed:         flag.Int("seed", 0, "Random seed"),
-		timeout:      flag.Int("timeout", 60*5, "Timeout in seconds (default 300s)"),
-		prompt:       flag.String("p", DefaultPrompt, "Prompt to use"),
-		imageFile:    flag.String("image", "", "Filename for an image to include"),
-		keepAlive:    flag.Float64("k", 0, "Keep alive duration in seconds"),
-		format:       flag.String("format", "benchstat", "Output format [benchstat|csv]"),
-		outputFile:   flag.String("output", "", "Output file for results (stdout if empty)"),
-		verbose:      flag.Bool("v", false, "Show system information"),
-		debug:        flag.Bool("debug", false, "Show debug information"),
-		warmup:       flag.Int("warmup", 1, "Number of warmup requests before timing"),
-		promptTokens: flag.Int("prompt-tokens", 0, "Generate prompt targeting ~N tokens (0 = use -p prompt)"),
-		numCtx:       flag.Int("num-ctx", 0, "Context size (0 = server default)"),
+		models:      flag.String("model", "", "Model to benchmark"),
+		epochs:      flag.Int("epochs", 6, "Number of epochs (iterations) per model"),
+		maxTokens:   flag.Int("max-tokens", 200, "Maximum tokens for model response"),
+		temperature: flag.Float64("temperature", 0, "Temperature parameter"),
+		seed:        flag.Int("seed", 0, "Random seed"),
+		timeout:     flag.Int("timeout", 60*5, "Timeout in seconds (default 300s)"),
+		prompt:      flag.String("p", DefaultPrompt, "Prompt to use"),
+		imageFile:   flag.String("image", "", "Filename for an image to include"),
+		keepAlive:   flag.Float64("k", 0, "Keep alive duration in seconds"),
+		format:      flag.String("format", "markdown", "Output format [benchstat|csv] (default benchstat)"),
+		outputFile:  flag.String("output", "", "Output file for results (stdout if empty)"),
+		verbose:     flag.Bool("v", false, "Show system information"),
+		debug:       flag.Bool("debug", false, "Show debug information"),
 	}

 	flag.Usage = func() {
@@ -541,12 +302,11 @@ func main() {
 		fmt.Fprintf(os.Stderr, "Options:\n")
 		flag.PrintDefaults()
 		fmt.Fprintf(os.Stderr, "\nExamples:\n")
-		fmt.Fprintf(os.Stderr, "  bench -model gemma3,llama3 -epochs 6\n")
-		fmt.Fprintf(os.Stderr, "  bench -model gemma3 -epochs 6 -prompt-tokens 512 -format csv\n")
+		fmt.Fprintf(os.Stderr, "  bench -model gpt-oss:20b -epochs 3 -temperature 0.7\n")
 	}
 	flag.Parse()

-	if !slices.Contains([]string{"benchstat", "csv"}, *fOpt.format) {
+	if !slices.Contains([]string{"markdown", "benchstat", "csv"}, *fOpt.format) {
 		fmt.Fprintf(os.Stderr, "ERROR: Unknown format '%s'\n", *fOpt.format)
 		os.Exit(1)
 	}
@@ -557,5 +317,5 @@ func main() {
 		return
 	}

-	BenchmarkModel(fOpt)
+	BenchmarkChat(fOpt)
 }
@@ -11,7 +11,6 @@ import (
 	"fmt"
 	"io"
 	"log"
-	"log/slog"
 	"math"
 	"net"
 	"net/http"
@@ -39,12 +38,9 @@ import (

 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/cmd/config"
-	"github.com/ollama/ollama/cmd/launch"
 	"github.com/ollama/ollama/cmd/tui"
 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
-	"github.com/ollama/ollama/internal/modelref"
-	"github.com/ollama/ollama/logutil"
 	"github.com/ollama/ollama/parser"
 	"github.com/ollama/ollama/progress"
 	"github.com/ollama/ollama/readline"
@@ -54,84 +50,46 @@ import (
 	"github.com/ollama/ollama/types/syncmap"
 	"github.com/ollama/ollama/version"
 	xcmd "github.com/ollama/ollama/x/cmd"
-	xcreate "github.com/ollama/ollama/x/create"
+	"github.com/ollama/ollama/x/create"
 	xcreateclient "github.com/ollama/ollama/x/create/client"
 	"github.com/ollama/ollama/x/imagegen"
 )

 func init() {
 	// Override default selectors to use Bubbletea TUI instead of raw terminal I/O.
-	launch.DefaultSingleSelector = func(title string, items []launch.SelectionItem, current string) (string, error) {
-		return runTUISingleSelector(title, items, current, nil)
+	config.DefaultSingleSelector = func(title string, items []config.ModelItem, current string) (string, error) {
+		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+		result, err := tui.SelectSingle(title, tuiItems, current)
+		if errors.Is(err, tui.ErrCancelled) {
+			return "", config.ErrCancelled
+		}
+		return result, err
 	}

-	launch.DefaultSingleSelectorWithUpdates = func(title string, items []launch.SelectionItem, current string, updates <-chan []launch.SelectionItem) (string, error) {
-		return runTUISingleSelector(title, items, current, updates)
+	config.DefaultMultiSelector = func(title string, items []config.ModelItem, preChecked []string) ([]string, error) {
+		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
+		if errors.Is(err, tui.ErrCancelled) {
+			return nil, config.ErrCancelled
+		}
+		return result, err
 	}

-	launch.DefaultMultiSelector = func(title string, items []launch.SelectionItem, preChecked []string) ([]string, error) {
-		return runTUIMultiSelector(title, items, preChecked, nil)
-	}
-
-	launch.DefaultMultiSelectorWithUpdates = func(title string, items []launch.SelectionItem, preChecked []string, updates <-chan []launch.SelectionItem) ([]string, error) {
-		return runTUIMultiSelector(title, items, preChecked, updates)
-	}
-
-	launch.DefaultSignIn = func(modelName, signInURL string) (string, error) {
+	config.DefaultSignIn = func(modelName, signInURL string) (string, error) {
 		userName, err := tui.RunSignIn(modelName, signInURL)
 		if errors.Is(err, tui.ErrCancelled) {
-			return "", launch.ErrCancelled
+			return "", config.ErrCancelled
 		}
 		return userName, err
 	}

-	launch.DefaultUpgrade = func(modelName, requiredPlan string) (string, error) {
-		plan, err := tui.RunUpgrade(modelName, requiredPlan)
+	config.DefaultConfirmPrompt = func(prompt string) (bool, error) {
+		ok, err := tui.RunConfirm(prompt)
 		if errors.Is(err, tui.ErrCancelled) {
-			return "", launch.ErrCancelled
+			return false, config.ErrCancelled
 		}
-		return plan, err
+		return ok, err
 	}
-
-	launch.DefaultConfirmPrompt = tui.RunConfirmWithOptions
-}
-
-func runTUISingleSelector(title string, items []launch.SelectionItem, current string, updates <-chan []launch.SelectionItem) (string, error) {
-	if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-		return "", fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-	}
-	tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-	result, err := tui.SelectSingleWithUpdates(title, tuiItems, current, convertSelectionItemUpdates(updates))
-	if errors.Is(err, tui.ErrCancelled) {
-		return "", launch.ErrCancelled
-	}
-	return result, err
-}
-
-func runTUIMultiSelector(title string, items []launch.SelectionItem, preChecked []string, updates <-chan []launch.SelectionItem) ([]string, error) {
-	if !term.IsTerminal(int(os.Stdin.Fd())) || !term.IsTerminal(int(os.Stdout.Fd())) {
-		return nil, fmt.Errorf("model selection requires an interactive terminal; use --model to run in headless mode")
-	}
-	tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-	result, err := tui.SelectMultipleWithUpdates(title, tuiItems, preChecked, convertSelectionItemUpdates(updates))
-	if errors.Is(err, tui.ErrCancelled) {
-		return nil, launch.ErrCancelled
-	}
-	return result, err
-}
-
-func convertSelectionItemUpdates(updates <-chan []launch.SelectionItem) <-chan []tui.SelectItem {
-	if updates == nil {
-		return nil
-	}
-	out := make(chan []tui.SelectItem, 1)
-	go func() {
-		defer close(out)
-		for items := range updates {
-			out <- tui.ReorderItems(tui.ConvertItems(items))
-		}
-	}()
-	return out
 }

 const ConnectInstructions = "If your browser did not open, navigate to:\n    %s\n\n"
@@ -173,50 +131,6 @@ func getModelfileName(cmd *cobra.Command) (string, error) {
 	return absName, nil
 }

-// isLocalhost returns true if the configured Ollama host is a loopback or unspecified address.
-func isLocalhost() bool {
-	host := envconfig.Host()
-	h, _, _ := net.SplitHostPort(host.Host)
-	if h == "localhost" {
-		return true
-	}
-	ip := net.ParseIP(h)
-	return ip != nil && (ip.IsLoopback() || ip.IsUnspecified())
-}
-
-func resolveExperimentalLocalModelDir(ref, filename string) string {
-	if ref == "" || filepath.IsAbs(ref) || filename == "" {
-		return ref
-	}
-
-	candidate := filepath.Join(filepath.Dir(filename), ref)
-	if xcreate.IsSafetensorsModelDir(candidate) || xcreate.IsTensorModelDir(candidate) {
-		return candidate
-	}
-
-	return ref
-}
-
-func resolveExperimentalDraftDir(ref, filename string) (string, error) {
-	if ref == "" {
-		return "", nil
-	}
-	if filepath.IsAbs(ref) {
-		if xcreate.IsSafetensorsModelDir(ref) {
-			return ref, nil
-		}
-		return "", fmt.Errorf("draft %s is not a supported safetensors model directory", ref)
-	}
-	if filename != "" {
-		candidate := filepath.Join(filepath.Dir(filename), ref)
-		if xcreate.IsSafetensorsModelDir(candidate) {
-			return candidate, nil
-		}
-	}
-
-	return "", fmt.Errorf("DRAFT model references are not supported with --experimental yet: %s", ref)
-}
-
 func CreateHandler(cmd *cobra.Command, args []string) error {
 	p := progress.NewProgress(os.Stderr)
 	defer p.Stop()
@@ -229,17 +143,8 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 	}

 	// Check for --experimental flag for safetensors model creation
-	// This gates both safetensors LLM and imagegen model creation
 	experimental, _ := cmd.Flags().GetBool("experimental")
-	draftQuantize, _ := cmd.Flags().GetString("draft-quantize")
-	if draftQuantize != "" && !experimental {
-		return errors.New("--draft-quantize requires --experimental")
-	}
 	if experimental {
-		if !isLocalhost() {
-			return errors.New("remote safetensor model creation not yet supported")
-		}
-
 		// Get Modelfile content - either from -f flag or default to "FROM ."
 		var reader io.Reader
 		filename, err := getModelfileName(cmd)
@@ -263,36 +168,59 @@ func CreateHandler(cmd *cobra.Command, args []string) error {
 			return fmt.Errorf("failed to parse Modelfile: %w", err)
 		}

-		modelDir, mfConfig, err := xcreateclient.ConfigFromModelfile(modelfile)
-		if err != nil {
-			return err
+		// Extract FROM path and configuration
+		var modelDir string
+		mfConfig := &xcreateclient.ModelfileConfig{}
+
+		for _, cmd := range modelfile.Commands {
+			switch cmd.Name {
+			case "model":
+				modelDir = cmd.Args
+			case "template":
+				mfConfig.Template = cmd.Args
+			case "system":
+				mfConfig.System = cmd.Args
+			case "license":
+				mfConfig.License = cmd.Args
+			case "parser":
+				mfConfig.Parser = cmd.Args
+			case "renderer":
+				mfConfig.Renderer = cmd.Args
+			}
 		}

-		modelDir = resolveExperimentalLocalModelDir(modelDir, filename)
-		if mfConfig.Draft != "" {
-			draftDir, err := resolveExperimentalDraftDir(mfConfig.Draft, filename)
-			if err != nil {
-				return err
-			}
-			mfConfig.Draft = draftDir
+		if modelDir == "" {
+			modelDir = "."
+		}
+
+		// Resolve relative paths based on Modelfile location
+		if !filepath.IsAbs(modelDir) && filename != "" {
+			modelDir = filepath.Join(filepath.Dir(filename), modelDir)
 		}

 		quantize, _ := cmd.Flags().GetString("quantize")
 		return xcreateclient.CreateModel(xcreateclient.CreateOptions{
-			ModelName:     modelName,
-			ModelDir:      modelDir,
-			Quantize:      quantize,
-			DraftQuantize: draftQuantize,
-			Modelfile:     mfConfig,
+			ModelName: modelName,
+			ModelDir:  modelDir,
+			Quantize:  quantize,
+			Modelfile: mfConfig,
 		}, p)
 	}

-	// Standard Modelfile + API path
 	var reader io.Reader

 	filename, err := getModelfileName(cmd)
 	if os.IsNotExist(err) {
 		if filename == "" {
+			// No Modelfile found - check if current directory is an image gen model
+			if create.IsTensorModelDir(".") {
+				quantize, _ := cmd.Flags().GetString("quantize")
+				return xcreateclient.CreateModel(xcreateclient.CreateOptions{
+					ModelName: modelName,
+					ModelDir:  ".",
+					Quantize:  quantize,
+				}, p)
+			}
 			reader = strings.NewReader("FROM .\n")
 		} else {
 			return errModelfileNotFound
@@ -478,14 +406,12 @@ func loadOrUnloadModel(cmd *cobra.Command, opts *runOptions) error {
 		return err
 	}

-	requestedCloud := modelref.HasExplicitCloudSource(opts.Model)
-
 	if info, err := client.Show(cmd.Context(), &api.ShowRequest{Model: opts.Model}); err != nil {
 		return err
-	} else if info.RemoteHost != "" || requestedCloud {
+	} else if info.RemoteHost != "" {
 		// Cloud model, no need to load/unload

-		isCloud := requestedCloud || strings.HasPrefix(info.RemoteHost, "https://ollama.com")
+		isCloud := strings.HasPrefix(info.RemoteHost, "https://ollama.com")

 		// Check if user is signed in for ollama.com cloud models
 		if isCloud {
@@ -496,14 +422,10 @@ func loadOrUnloadModel(cmd *cobra.Command, opts *runOptions) error {

 		if opts.ShowConnect {
 			p.StopAndClear()
-			remoteModel := info.RemoteModel
-			if remoteModel == "" {
-				remoteModel = opts.Model
-			}
 			if isCloud {
-				fmt.Fprintf(os.Stderr, "Connecting to '%s' on 'ollama.com' ⚡\n", remoteModel)
+				fmt.Fprintf(os.Stderr, "Connecting to '%s' on 'ollama.com' ⚡\n", info.RemoteModel)
 			} else {
-				fmt.Fprintf(os.Stderr, "Connecting to '%s' on '%s'\n", remoteModel, info.RemoteHost)
+				fmt.Fprintf(os.Stderr, "Connecting to '%s' on '%s'\n", info.RemoteModel, info.RemoteHost)
 			}
 		}

@@ -575,64 +497,6 @@ func generateEmbedding(cmd *cobra.Command, modelName, input string, keepAlive *a
 	return nil
 }

-// TODO(parthsareen): consolidate with TUI signin flow
-func handleCloudAuthorizationError(err error) bool {
-	var authErr api.AuthorizationError
-	if errors.As(err, &authErr) && authErr.StatusCode == http.StatusUnauthorized {
-		fmt.Printf("You need to be signed in to Ollama to run Cloud models.\n\n")
-		if authErr.SigninURL != "" {
-			fmt.Printf(ConnectInstructions, authErr.SigninURL)
-		}
-		return true
-	}
-
-	return false
-}
-
-// TEMP(drifkin): To match legacy `ollama run some-model:cloud` behavior, we
-// best-effort pull cloud stub files for any explicit cloud source models.
-// Remove this once `/api/tags` is cloud-aware.
-func ensureCloudStub(ctx context.Context, client *api.Client, modelName string) {
-	if !modelref.HasExplicitCloudSource(modelName) {
-		return
-	}
-
-	normalizedName, _, err := modelref.NormalizePullName(modelName)
-	if err != nil {
-		slog.Warn("failed to normalize pull name", "model", modelName, "error", err, "normalizedName", normalizedName)
-		return
-	}
-
-	listResp, err := client.List(ctx)
-	if err != nil {
-		slog.Warn("failed to list models", "error", err)
-		return
-	}
-
-	if hasListedModelName(listResp.Models, modelName) || hasListedModelName(listResp.Models, normalizedName) {
-		return
-	}
-
-	logutil.Trace("pulling cloud stub", "model", modelName, "normalizedName", normalizedName)
-	err = client.Pull(ctx, &api.PullRequest{
-		Model: normalizedName,
-	}, func(api.ProgressResponse) error {
-		return nil
-	})
-	if err != nil {
-		slog.Warn("failed to pull cloud stub", "model", modelName, "error", err)
-	}
-}
-
-func hasListedModelName(models []api.ListModelResponse, name string) bool {
-	for _, m := range models {
-		if strings.EqualFold(m.Name, name) || strings.EqualFold(m.Model, name) {
-			return true
-		}
-	}
-	return false
-}
-
 func RunHandler(cmd *cobra.Command, args []string) error {
 	interactive := true

@@ -663,10 +527,10 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 			opts.Think = &api.ThinkValue{Value: true}
 		case "false":
 			opts.Think = &api.ThinkValue{Value: false}
-		case "high", "medium", "low", "max":
+		case "high", "medium", "low":
 			opts.Think = &api.ThinkValue{Value: thinkStr}
 		default:
-			return fmt.Errorf("invalid value for --think: %q (must be true, false, high, medium, low, or max)", thinkStr)
+			return fmt.Errorf("invalid value for --think: %q (must be true, false, high, medium, or low)", thinkStr)
 		}
 	} else {
 		opts.Think = nil
@@ -721,6 +585,17 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 	}
 	opts.WordWrap = !nowrap

+	useImagegen := false
+	if cmd.Flags().Lookup("imagegen") != nil {
+		useImagegen, err = cmd.Flags().GetBool("imagegen")
+		if err != nil {
+			return err
+		}
+	}
+	if useImagegen {
+		opts.Options["use_imagegen_runner"] = true
+	}
+
 	// Fill out the rest of the options based on information about the
 	// model.
 	client, err := api.ClientFromEnvironment()
@@ -729,16 +604,12 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 	}

 	name := args[0]
-	requestedCloud := modelref.HasExplicitCloudSource(name)

 	info, err := func() (*api.ShowResponse, error) {
 		showReq := &api.ShowRequest{Name: name}
 		info, err := client.Show(cmd.Context(), showReq)
 		var se api.StatusError
 		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
-			if requestedCloud {
-				return nil, err
-			}
 			if err := PullHandler(cmd, []string{name}); err != nil {
 				return nil, err
 			}
@@ -747,21 +618,15 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		return info, err
 	}()
 	if err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
 		return err
 	}

-	ensureCloudStub(cmd.Context(), client, name)
-
 	opts.Think, err = inferThinkingOption(&info.Capabilities, &opts, thinkFlag.Changed)
 	if err != nil {
 		return err
 	}

-	audioCapable := slices.Contains(info.Capabilities, model.CapabilityAudio)
-	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision) || audioCapable
+	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision)

 	// TODO: remove the projector info and vision info checks below,
 	// these are left in for backwards compatibility with older servers
@@ -776,7 +641,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {
 		}
 	}

-	applyShowResponseToRunOptions(&opts, info)
+	opts.ParentModel = info.Details.ParentModel

 	// Check if this is an embedding model
 	isEmbeddingModel := slices.Contains(info.Capabilities, model.CapabilityEmbedding)
@@ -847,13 +712,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {

 		return generateInteractive(cmd, opts)
 	}
-	if err := generate(cmd, opts); err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
-		return err
-	}
-	return nil
+	return generate(cmd, opts)
 }

 func SigninHandler(cmd *cobra.Command, args []string) error {
@@ -1492,30 +1351,23 @@ func PullHandler(cmd *cobra.Command, args []string) error {
 type generateContextKey string

 type runOptions struct {
-	Model          string
-	ParentModel    string
-	LoadedMessages []api.Message
-	Prompt         string
-	Messages       []api.Message
-	WordWrap       bool
-	Format         string
-	System         string
-	Images         []api.ImageData
-	Options        map[string]any
-	MultiModal     bool
-	KeepAlive      *api.Duration
-	Think          *api.ThinkValue
-	HideThinking   bool
-	ShowConnect    bool
+	Model        string
+	ParentModel  string
+	Prompt       string
+	Messages     []api.Message
+	WordWrap     bool
+	Format       string
+	System       string
+	Images       []api.ImageData
+	Options      map[string]any
+	MultiModal   bool
+	KeepAlive    *api.Duration
+	Think        *api.ThinkValue
+	HideThinking bool
+	ShowConnect  bool
 }

 func (r runOptions) Copy() runOptions {
-	var loadedMessages []api.Message
-	if r.LoadedMessages != nil {
-		loadedMessages = make([]api.Message, len(r.LoadedMessages))
-		copy(loadedMessages, r.LoadedMessages)
-	}
-
 	var messages []api.Message
 	if r.Messages != nil {
 		messages = make([]api.Message, len(r.Messages))
@@ -1543,29 +1395,23 @@ func (r runOptions) Copy() runOptions {
 	}

 	return runOptions{
-		Model:          r.Model,
-		ParentModel:    r.ParentModel,
-		LoadedMessages: loadedMessages,
-		Prompt:         r.Prompt,
-		Messages:       messages,
-		WordWrap:       r.WordWrap,
-		Format:         r.Format,
-		System:         r.System,
-		Images:         images,
-		Options:        opts,
-		MultiModal:     r.MultiModal,
-		KeepAlive:      r.KeepAlive,
-		Think:          think,
-		HideThinking:   r.HideThinking,
-		ShowConnect:    r.ShowConnect,
+		Model:        r.Model,
+		ParentModel:  r.ParentModel,
+		Prompt:       r.Prompt,
+		Messages:     messages,
+		WordWrap:     r.WordWrap,
+		Format:       r.Format,
+		System:       r.System,
+		Images:       images,
+		Options:      opts,
+		MultiModal:   r.MultiModal,
+		KeepAlive:    r.KeepAlive,
+		Think:        think,
+		HideThinking: r.HideThinking,
+		ShowConnect:  r.ShowConnect,
 	}
 }

-func applyShowResponseToRunOptions(opts *runOptions, info *api.ShowResponse) {
-	opts.ParentModel = info.Details.ParentModel
-	opts.LoadedMessages = slices.Clone(info.Messages)
-}
-
 type displayResponseState struct {
 	lineLength int
 	wordBuffer string
@@ -1573,9 +1419,6 @@ type displayResponseState struct {

 func displayResponse(content string, wordWrap bool, state *displayResponseState) {
 	termWidth, _, _ := term.GetSize(int(os.Stdout.Fd()))
-	if termWidth == 0 {
-		termWidth = 80
-	}
 	if wordWrap && termWidth >= 10 {
 		for _, ch := range content {
 			if state.lineLength+1 > termWidth-5 {
@@ -2009,7 +1852,7 @@ func appendEnvDocs(cmd *cobra.Command, envs []envconfig.EnvVar) {
 Environment Variables:
 `
 	for _, e := range envs {
-		envUsage += fmt.Sprintf("      %-27s   %s\n", e.Name, e.Description)
+		envUsage += fmt.Sprintf("      %-24s   %s\n", e.Name, e.Description)
 	}

 	cmd.SetUsageTemplate(cmd.UsageTemplate() + envUsage)
@@ -2049,77 +1892,6 @@ func ensureServerRunning(ctx context.Context) error {
 	}
 }

-func launchInteractiveModel(cmd *cobra.Command, modelName string) error {
-	opts := runOptions{
-		Model:       modelName,
-		WordWrap:    os.Getenv("TERM") == "xterm-256color",
-		Options:     map[string]any{},
-		ShowConnect: true,
-	}
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-
-	requestedCloud := modelref.HasExplicitCloudSource(modelName)
-
-	info, err := func() (*api.ShowResponse, error) {
-		showReq := &api.ShowRequest{Name: modelName}
-		info, err := client.Show(cmd.Context(), showReq)
-		var se api.StatusError
-		if errors.As(err, &se) && se.StatusCode == http.StatusNotFound {
-			if requestedCloud {
-				return nil, err
-			}
-			if err := PullHandler(cmd, []string{modelName}); err != nil {
-				return nil, err
-			}
-			return client.Show(cmd.Context(), &api.ShowRequest{Name: modelName})
-		}
-		return info, err
-	}()
-	if err != nil {
-		if handleCloudAuthorizationError(err) {
-			return nil
-		}
-		return err
-	}
-
-	ensureCloudStub(cmd.Context(), client, modelName)
-
-	opts.Think, err = inferThinkingOption(&info.Capabilities, &opts, false)
-	if err != nil {
-		return err
-	}
-
-	audioCapable := slices.Contains(info.Capabilities, model.CapabilityAudio)
-	opts.MultiModal = slices.Contains(info.Capabilities, model.CapabilityVision) || audioCapable
-
-	// TODO: remove the projector info and vision info checks below,
-	// these are left in for backwards compatibility with older servers
-	// that don't have the capabilities field in the model info
-	if len(info.ProjectorInfo) != 0 {
-		opts.MultiModal = true
-	}
-	for k := range info.ModelInfo {
-		if strings.Contains(k, ".vision.") {
-			opts.MultiModal = true
-			break
-		}
-	}
-
-	applyShowResponseToRunOptions(&opts, info)
-
-	if err := loadOrUnloadModel(cmd, &opts); err != nil {
-		return fmt.Errorf("error loading model: %w", err)
-	}
-	if err := generateInteractive(cmd, opts); err != nil {
-		return fmt.Errorf("error running model: %w", err)
-	}
-	return nil
-}
-
 // runInteractiveTUI runs the main interactive TUI menu.
 func runInteractiveTUI(cmd *cobra.Command) {
 	// Ensure the server is running before showing the TUI
@@ -2128,113 +1900,175 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		return
 	}

-	accountPrefetch := launch.StartAccountStatePrefetch(cmd.Context())
-	deps := launcherDeps{
-		buildState:          launch.BuildLauncherState,
-		runMenu:             tui.RunMenu,
-		resolveRunModel:     launch.ResolveRunModel,
-		launchIntegration:   launch.LaunchIntegration,
-		runModel:            launchInteractiveModel,
-		accountState:        accountPrefetch.StateIfReady,
-		accountStateUpdates: accountPrefetch.StateUpdates,
+	// Selector adapters for tui
+	singleSelector := func(title string, items []config.ModelItem, current string) (string, error) {
+		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+		result, err := tui.SelectSingle(title, tuiItems, current)
+		if errors.Is(err, tui.ErrCancelled) {
+			return "", config.ErrCancelled
+		}
+		return result, err
+	}
+
+	multiSelector := func(title string, items []config.ModelItem, preChecked []string) ([]string, error) {
+		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
+		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
+		if errors.Is(err, tui.ErrCancelled) {
+			return nil, config.ErrCancelled
+		}
+		return result, err
 	}

 	for {
-		continueLoop, err := runInteractiveTUIStep(cmd, deps)
+		result, err := tui.Run()
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		}
-		if !continueLoop {
 			return
 		}
-	}
-}

-type launcherDeps struct {
-	buildState          func(context.Context) (*launch.LauncherState, error)
-	runMenu             func(*launch.LauncherState) (tui.TUIAction, error)
-	resolveRunModel     func(context.Context, launch.RunModelRequest) (string, error)
-	launchIntegration   func(context.Context, launch.IntegrationLaunchRequest) error
-	runModel            func(*cobra.Command, string) error
-	accountState        func() *launch.AccountState
-	accountStateUpdates func(context.Context) <-chan *launch.AccountState
-}
+		runModel := func(modelName string) {
+			client, err := api.ClientFromEnvironment()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				return
+			}
+			if err := config.ShowOrPull(cmd.Context(), client, modelName); err != nil {
+				if errors.Is(err, config.ErrCancelled) {
+					return
+				}
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				return
+			}
+			_ = config.SetLastModel(modelName)
+			opts := runOptions{
+				Model:       modelName,
+				WordWrap:    os.Getenv("TERM") == "xterm-256color",
+				Options:     map[string]any{},
+				ShowConnect: true,
+			}
+			if err := loadOrUnloadModel(cmd, &opts); err != nil {
+				fmt.Fprintf(os.Stderr, "Error loading model: %v\n", err)
+				return
+			}
+			if err := generateInteractive(cmd, opts); err != nil {
+				fmt.Fprintf(os.Stderr, "Error running model: %v\n", err)
+			}
+		}

-func runInteractiveTUIStep(cmd *cobra.Command, deps launcherDeps) (bool, error) {
-	state, err := deps.buildState(cmd.Context())
-	if err != nil {
-		return false, fmt.Errorf("build launcher state: %w", err)
-	}
-	if state != nil && deps.accountState != nil {
-		state.AccountState = deps.accountState()
-	}
+		launchIntegration := func(name string) bool {
+			if err := config.EnsureInstalled(name); err != nil {
+				fmt.Fprintf(os.Stderr, "Error: %v\n", err)
+				return true
+			}
+			// If not configured or model no longer exists, prompt for model selection
+			configuredModel := config.IntegrationModel(name)
+			if configuredModel == "" || !config.ModelExists(cmd.Context(), configuredModel) || config.IsCloudModelDisabled(cmd.Context(), configuredModel) {
+				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), name, singleSelector, multiSelector)
+				if errors.Is(err, config.ErrCancelled) {
+					return false // Return to main menu
+				}
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error configuring %s: %v\n", name, err)
+					return true
+				}
+			}
+			if err := config.LaunchIntegration(name); err != nil {
+				fmt.Fprintf(os.Stderr, "Error launching %s: %v\n", name, err)
+			}
+			return true
+		}

-	action, err := deps.runMenu(state)
-	if err != nil {
-		return false, fmt.Errorf("run launcher menu: %w", err)
-	}
-
-	return runLauncherAction(cmd, action, deps)
-}
-
-func saveLauncherSelection(action tui.TUIAction) {
-	// Best effort only: this affects menu recall, not launch correctness.
-	_ = config.SetLastSelection(action.LastSelection())
-}
-
-func runLauncherAction(cmd *cobra.Command, action tui.TUIAction, deps launcherDeps) (bool, error) {
-	switch action.Kind {
-	case tui.TUIActionNone:
-		return false, nil
-	case tui.TUIActionRunModel:
-		saveLauncherSelection(action)
-		req := action.RunModelRequest()
-		if deps.accountState != nil {
-			req.AccountState = deps.accountState()
-			req.AccountStateProvider = deps.accountState
+		switch result.Selection {
+		case tui.SelectionNone:
+			// User quit
+			return
+		case tui.SelectionRunModel:
+			_ = config.SetLastSelection("run")
+			if modelName := config.LastModel(); modelName != "" && !config.IsCloudModelDisabled(cmd.Context(), modelName) {
+				runModel(modelName)
+			} else {
+				modelName, err := config.SelectModelWithSelector(cmd.Context(), singleSelector)
+				if errors.Is(err, config.ErrCancelled) {
+					continue // Return to main menu
+				}
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error selecting model: %v\n", err)
+					continue
+				}
+				runModel(modelName)
+			}
+		case tui.SelectionChangeRunModel:
+			_ = config.SetLastSelection("run")
+			// Use model from modal if selected, otherwise show picker
+			modelName := result.Model
+			if modelName == "" {
+				var err error
+				modelName, err = config.SelectModelWithSelector(cmd.Context(), singleSelector)
+				if errors.Is(err, config.ErrCancelled) {
+					continue // Return to main menu
+				}
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error selecting model: %v\n", err)
+					continue
+				}
+			}
+			if config.IsCloudModelDisabled(cmd.Context(), modelName) {
+				continue // Return to main menu
+			}
+			runModel(modelName)
+		case tui.SelectionIntegration:
+			_ = config.SetLastSelection(result.Integration)
+			if !launchIntegration(result.Integration) {
+				continue // Return to main menu
+			}
+		case tui.SelectionChangeIntegration:
+			_ = config.SetLastSelection(result.Integration)
+			if len(result.Models) > 0 {
+				// Filter out cloud-disabled models
+				var filtered []string
+				for _, m := range result.Models {
+					if !config.IsCloudModelDisabled(cmd.Context(), m) {
+						filtered = append(filtered, m)
+					}
+				}
+				if len(filtered) == 0 {
+					continue
+				}
+				result.Models = filtered
+				// Multi-select from modal (Editor integrations)
+				if err := config.SaveAndEditIntegration(result.Integration, result.Models); err != nil {
+					fmt.Fprintf(os.Stderr, "Error configuring %s: %v\n", result.Integration, err)
+					continue
+				}
+				if err := config.LaunchIntegrationWithModel(result.Integration, result.Models[0]); err != nil {
+					fmt.Fprintf(os.Stderr, "Error launching %s: %v\n", result.Integration, err)
+				}
+			} else if result.Model != "" {
+				if config.IsCloudModelDisabled(cmd.Context(), result.Model) {
+					continue
+				}
+				// Single-select from modal - save and launch
+				if err := config.SaveIntegration(result.Integration, []string{result.Model}); err != nil {
+					fmt.Fprintf(os.Stderr, "Error saving config: %v\n", err)
+					continue
+				}
+				if err := config.LaunchIntegrationWithModel(result.Integration, result.Model); err != nil {
+					fmt.Fprintf(os.Stderr, "Error launching %s: %v\n", result.Integration, err)
+				}
+			} else {
+				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), result.Integration, singleSelector, multiSelector)
+				if errors.Is(err, config.ErrCancelled) {
+					continue // Return to main menu
+				}
+				if err != nil {
+					fmt.Fprintf(os.Stderr, "Error configuring %s: %v\n", result.Integration, err)
+					continue
+				}
+				if err := config.LaunchIntegration(result.Integration); err != nil {
+					fmt.Fprintf(os.Stderr, "Error launching %s: %v\n", result.Integration, err)
+				}
+			}
 		}
-		req.AccountStateUpdates = deps.accountStateUpdates
-		modelName, err := deps.resolveRunModel(cmd.Context(), req)
-		if errors.Is(err, launch.ErrCancelled) {
-			return true, nil
-		}
-		if err != nil {
-			return true, fmt.Errorf("selecting model: %w", err)
-		}
-		if err := deps.runModel(cmd, modelName); err != nil {
-			return true, err
-		}
-		return true, nil
-	case tui.TUIActionLaunchIntegration:
-		saveLauncherSelection(action)
-		req := action.IntegrationLaunchRequest()
-		if deps.accountState != nil {
-			req.AccountState = deps.accountState()
-			req.AccountStateProvider = deps.accountState
-		}
-		req.AccountStateUpdates = deps.accountStateUpdates
-		err := deps.launchIntegration(cmd.Context(), req)
-		if errors.Is(err, launch.ErrCancelled) {
-			return true, nil
-		}
-		if err != nil {
-			return true, fmt.Errorf("launching %s: %w", action.Integration, err)
-		}
-		if launcherActionExitsLoop(action.Integration) {
-			return false, nil
-		}
-		return true, nil
-	default:
-		return false, fmt.Errorf("unknown launcher action: %d", action.Kind)
-	}
-}
-
-func launcherActionExitsLoop(integration string) bool {
-	switch integration {
-	case "codex-app", "vscode":
-		return true
-	default:
-		return false
 	}
 }

@@ -2277,9 +2111,6 @@ func NewCLI() *cobra.Command {
 			if experimental, _ := cmd.Flags().GetBool("experimental"); experimental {
 				return nil
 			}
-			if draftQuantize, _ := cmd.Flags().GetString("draft-quantize"); draftQuantize != "" {
-				return errors.New("--draft-quantize requires --experimental")
-			}
 			return checkServerHeartbeat(cmd, args)
 		},
 		RunE: CreateHandler,
@@ -2287,7 +2118,6 @@ func NewCLI() *cobra.Command {

 	createCmd.Flags().StringP("file", "f", "", "Name of the Modelfile (default \"Modelfile\")")
 	createCmd.Flags().StringP("quantize", "q", "", "Quantize model to this level (e.g. q4_K_M)")
-	createCmd.Flags().String("draft-quantize", "", "Quantize draft model to this level")
 	createCmd.Flags().Bool("experimental", false, "Enable experimental safetensors model creation")

 	showCmd := &cobra.Command{
@@ -2473,7 +2303,6 @@ func NewCLI() *cobra.Command {
 				envVars["OLLAMA_CONTEXT_LENGTH"],
 				envVars["OLLAMA_KEEP_ALIVE"],
 				envVars["OLLAMA_MAX_LOADED_MODELS"],
-				envVars["OLLAMA_MAX_TRANSFER_STREAMS"],
 				envVars["OLLAMA_MAX_QUEUE"],
 				envVars["OLLAMA_MODELS"],
 				envVars["OLLAMA_NUM_PARALLEL"],
@@ -2509,7 +2338,7 @@ func NewCLI() *cobra.Command {
 		copyCmd,
 		deleteCmd,
 		runnerCmd,
-		launch.LaunchCmd(checkServerHeartbeat, runInteractiveTUI),
+		config.LaunchCmd(checkServerHeartbeat, runInteractiveTUI),
 	)

 	return rootCmd
@@ -1,305 +0,0 @@
-package cmd
-
-import (
-	"context"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/ollama/ollama/cmd/config"
-	"github.com/ollama/ollama/cmd/launch"
-	"github.com/ollama/ollama/cmd/tui"
-)
-
-func setCmdTestHome(t *testing.T, dir string) {
-	t.Helper()
-	t.Setenv("HOME", dir)
-	t.Setenv("USERPROFILE", dir)
-}
-
-func unexpectedRunModelResolution(t *testing.T) func(context.Context, launch.RunModelRequest) (string, error) {
-	t.Helper()
-	return func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-		t.Fatalf("did not expect run-model resolution: %+v", req)
-		return "", nil
-	}
-}
-
-func unexpectedIntegrationLaunch(t *testing.T) func(context.Context, launch.IntegrationLaunchRequest) error {
-	t.Helper()
-	return func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-		t.Fatalf("did not expect integration launch: %+v", req)
-		return nil
-	}
-}
-
-func unexpectedModelLaunch(t *testing.T) func(*cobra.Command, string) error {
-	t.Helper()
-	return func(cmd *cobra.Command, model string) error {
-		t.Fatalf("did not expect chat launch: %s", model)
-		return nil
-	}
-}
-
-func TestRunInteractiveTUI_RunModelActionsUseResolveRunModel(t *testing.T) {
-	tests := []struct {
-		name      string
-		action    tui.TUIAction
-		wantForce bool
-		wantModel string
-	}{
-		{
-			name:      "enter uses saved model flow",
-			action:    tui.TUIAction{Kind: tui.TUIActionRunModel},
-			wantModel: "qwen3:8b",
-		},
-		{
-			name:      "right forces picker",
-			action:    tui.TUIAction{Kind: tui.TUIActionRunModel, ForceConfigure: true},
-			wantForce: true,
-			wantModel: "glm-5:cloud",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setCmdTestHome(t, t.TempDir())
-
-			var menuCalls int
-			runMenu := func(state *launch.LauncherState) (tui.TUIAction, error) {
-				menuCalls++
-				if menuCalls == 1 {
-					return tt.action, nil
-				}
-				return tui.TUIAction{Kind: tui.TUIActionNone}, nil
-			}
-
-			var gotReq launch.RunModelRequest
-			var launched string
-			prefetchedAccount := &launch.AccountState{}
-			accountUpdates := func(context.Context) <-chan *launch.AccountState { return nil }
-			deps := launcherDeps{
-				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
-					return &launch.LauncherState{}, nil
-				},
-				runMenu: func(state *launch.LauncherState) (tui.TUIAction, error) {
-					if state.AccountState != prefetchedAccount {
-						t.Fatalf("prefetched account state was not piped to menu state")
-					}
-					return runMenu(state)
-				},
-				resolveRunModel: func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-					gotReq = req
-					return tt.wantModel, nil
-				},
-				launchIntegration: unexpectedIntegrationLaunch(t),
-				runModel: func(cmd *cobra.Command, model string) error {
-					launched = model
-					return nil
-				},
-				accountState: func() *launch.AccountState {
-					return prefetchedAccount
-				},
-				accountStateUpdates: accountUpdates,
-			}
-
-			cmd := &cobra.Command{}
-			cmd.SetContext(context.Background())
-			for {
-				continueLoop, err := runInteractiveTUIStep(cmd, deps)
-				if err != nil {
-					t.Fatalf("unexpected step error: %v", err)
-				}
-				if !continueLoop {
-					break
-				}
-			}
-
-			if gotReq.ForcePicker != tt.wantForce {
-				t.Fatalf("expected ForcePicker=%v, got %v", tt.wantForce, gotReq.ForcePicker)
-			}
-			if gotReq.AccountState != prefetchedAccount {
-				t.Fatalf("expected prefetched account state to be passed to run model request")
-			}
-			if gotReq.AccountStateUpdates == nil {
-				t.Fatalf("expected account state updates to be passed to run model request")
-			}
-			if launched != tt.wantModel {
-				t.Fatalf("expected interactive launcher to run %q, got %q", tt.wantModel, launched)
-			}
-			if got := config.LastSelection(); got != "run" {
-				t.Fatalf("expected last selection to be run, got %q", got)
-			}
-		})
-	}
-}
-
-func TestRunInteractiveTUI_IntegrationActionsUseLaunchIntegration(t *testing.T) {
-	tests := []struct {
-		name      string
-		action    tui.TUIAction
-		wantForce bool
-	}{
-		{
-			name:   "enter launches integration",
-			action: tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"},
-		},
-		{
-			name:      "right forces configure",
-			action:    tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude", ForceConfigure: true},
-			wantForce: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			setCmdTestHome(t, t.TempDir())
-
-			var menuCalls int
-			runMenu := func(state *launch.LauncherState) (tui.TUIAction, error) {
-				menuCalls++
-				if menuCalls == 1 {
-					return tt.action, nil
-				}
-				return tui.TUIAction{Kind: tui.TUIActionNone}, nil
-			}
-
-			var gotReq launch.IntegrationLaunchRequest
-			prefetchedAccount := &launch.AccountState{}
-			accountUpdates := func(context.Context) <-chan *launch.AccountState { return nil }
-			deps := launcherDeps{
-				buildState: func(ctx context.Context) (*launch.LauncherState, error) {
-					return &launch.LauncherState{}, nil
-				},
-				runMenu: func(state *launch.LauncherState) (tui.TUIAction, error) {
-					if state.AccountState != prefetchedAccount {
-						t.Fatalf("prefetched account state was not piped to menu state")
-					}
-					return runMenu(state)
-				},
-				resolveRunModel: unexpectedRunModelResolution(t),
-				launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-					gotReq = req
-					return nil
-				},
-				runModel: unexpectedModelLaunch(t),
-				accountState: func() *launch.AccountState {
-					return prefetchedAccount
-				},
-				accountStateUpdates: accountUpdates,
-			}
-
-			cmd := &cobra.Command{}
-			cmd.SetContext(context.Background())
-			for {
-				continueLoop, err := runInteractiveTUIStep(cmd, deps)
-				if err != nil {
-					t.Fatalf("unexpected step error: %v", err)
-				}
-				if !continueLoop {
-					break
-				}
-			}
-
-			if gotReq.Name != "claude" {
-				t.Fatalf("expected integration name to be passed through, got %q", gotReq.Name)
-			}
-			if gotReq.ForceConfigure != tt.wantForce {
-				t.Fatalf("expected ForceConfigure=%v, got %v", tt.wantForce, gotReq.ForceConfigure)
-			}
-			if gotReq.AccountState != prefetchedAccount {
-				t.Fatalf("expected prefetched account state to be passed to integration request")
-			}
-			if gotReq.AccountStateUpdates == nil {
-				t.Fatalf("expected account state updates to be passed to integration request")
-			}
-			if got := config.LastSelection(); got != "claude" {
-				t.Fatalf("expected last selection to be claude, got %q", got)
-			}
-		})
-	}
-}
-
-func TestRunLauncherAction_RunModelContinuesAfterCancellation(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionRunModel}, launcherDeps{
-		buildState: nil,
-		runMenu:    nil,
-		resolveRunModel: func(ctx context.Context, req launch.RunModelRequest) (string, error) {
-			return "", launch.ErrCancelled
-		},
-		launchIntegration: unexpectedIntegrationLaunch(t),
-		runModel:          unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error on cancellation, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected cancellation to continue the menu loop")
-	}
-}
-
-func TestRunLauncherAction_GUIAppsExitTUILoop(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	for _, integration := range []string{"codex-app", "vscode"} {
-		continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: integration}, launcherDeps{
-			resolveRunModel: unexpectedRunModelResolution(t),
-			launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-				return nil
-			},
-			runModel: unexpectedModelLaunch(t),
-		})
-		if err != nil {
-			t.Fatalf("expected nil error for %s, got %v", integration, err)
-		}
-		if continueLoop {
-			t.Fatalf("expected %s launch to exit the TUI loop (return false)", integration)
-		}
-	}
-
-	// Other integrations should continue the TUI loop (return true).
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return nil
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected non-vscode integration to continue the TUI loop (return true)")
-	}
-}
-
-func TestRunLauncherAction_IntegrationContinuesAfterCancellation(t *testing.T) {
-	setCmdTestHome(t, t.TempDir())
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(context.Background())
-
-	continueLoop, err := runLauncherAction(cmd, tui.TUIAction{Kind: tui.TUIActionLaunchIntegration, Integration: "claude"}, launcherDeps{
-		buildState:      nil,
-		runMenu:         nil,
-		resolveRunModel: unexpectedRunModelResolution(t),
-		launchIntegration: func(ctx context.Context, req launch.IntegrationLaunchRequest) error {
-			return launch.ErrCancelled
-		},
-		runModel: unexpectedModelLaunch(t),
-	})
-	if err != nil {
-		t.Fatalf("expected nil error on cancellation, got %v", err)
-	}
-	if !continueLoop {
-		t.Fatal("expected cancellation to continue the menu loop")
-	}
-}
@@ -9,7 +9,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"os"
-	"path/filepath"
 	"reflect"
 	"strings"
 	"testing"
@@ -302,7 +301,7 @@ Weigh anchor!
 				ParameterSize:     "7B",
 				QuantizationLevel: "FP16",
 			},
-			Requires: "0.19.0",
+			Requires: "0.14.0",
 		}, false, &b); err != nil {
 			t.Fatal(err)
 		}
@@ -311,17 +310,10 @@ Weigh anchor!
    architecture    test      
    parameters      7B        
    quantization    FP16      
-    requires        0.19.0
+    requires        0.14.0    

 `
-		trimLinePadding := func(s string) string {
-			lines := strings.Split(s, "\n")
-			for i, line := range lines {
-				lines[i] = strings.TrimRight(line, " \t\r")
-			}
-			return strings.Join(lines, "\n")
-		}
-		if diff := cmp.Diff(trimLinePadding(expect), trimLinePadding(b.String())); diff != "" {
+		if diff := cmp.Diff(expect, b.String()); diff != "" {
 			t.Errorf("unexpected output (-want +got):\n%s", diff)
 		}
 	})
@@ -713,347 +705,6 @@ func TestRunEmbeddingModelNoInput(t *testing.T) {
 	}
 }

-func TestRunHandler_CloudAuthErrorOnShow_PrintsSigninMessage(t *testing.T) {
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusUnauthorized)
-			if err := json.NewEncoder(w).Encode(map[string]string{
-				"error":      "unauthorized",
-				"signin_url": "https://ollama.com/signin",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	oldStdout := os.Stdout
-	readOut, writeOut, _ := os.Pipe()
-	os.Stdout = writeOut
-	t.Cleanup(func() { os.Stdout = oldStdout })
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-
-	_ = writeOut.Close()
-	var out bytes.Buffer
-	_, _ = io.Copy(&out, readOut)
-
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if generateCalled {
-		t.Fatal("expected run to stop before /api/generate after unauthorized /api/show")
-	}
-
-	if !strings.Contains(out.String(), "You need to be signed in to Ollama to run Cloud models.") {
-		t.Fatalf("expected sign-in guidance message, got %q", out.String())
-	}
-
-	if !strings.Contains(out.String(), "https://ollama.com/signin") {
-		t.Fatalf("expected signin_url in output, got %q", out.String())
-	}
-}
-
-func TestRunHandler_CloudAuthErrorOnGenerate_PrintsSigninMessage(t *testing.T) {
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusUnauthorized)
-			if err := json.NewEncoder(w).Encode(map[string]string{
-				"error":      "unauthorized",
-				"signin_url": "https://ollama.com/signin",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	oldStdout := os.Stdout
-	readOut, writeOut, _ := os.Pipe()
-	os.Stdout = writeOut
-	t.Cleanup(func() { os.Stdout = oldStdout })
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-
-	_ = writeOut.Close()
-	var out bytes.Buffer
-	_, _ = io.Copy(&out, readOut)
-
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if !strings.Contains(out.String(), "You need to be signed in to Ollama to run Cloud models.") {
-		t.Fatalf("expected sign-in guidance message, got %q", out.String())
-	}
-
-	if !strings.Contains(out.String(), "https://ollama.com/signin") {
-		t.Fatalf("expected signin_url in output, got %q", out.String())
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubMissing_PullsNormalizedNameTEMP(t *testing.T) {
-	var pulledModel string
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{Models: nil}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			var req api.PullRequest
-			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-				http.Error(w, err.Error(), http.StatusBadRequest)
-				return
-			}
-			pulledModel = req.Model
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ProgressResponse{Status: "success"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if pulledModel != "gpt-oss:20b-cloud" {
-		t.Fatalf("expected normalized pull model %q, got %q", "gpt-oss:20b-cloud", pulledModel)
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called")
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubPresent_SkipsPullTEMP(t *testing.T) {
-	var pullCalled bool
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{
-				Models: []api.ListModelResponse{{Name: "gpt-oss:20b-cloud"}},
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			pullCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ProgressResponse{Status: "success"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if pullCalled {
-		t.Fatal("expected /api/pull not to be called when cloud stub already exists")
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called")
-	}
-}
-
-func TestRunHandler_ExplicitCloudStubPullFailure_IsBestEffortTEMP(t *testing.T) {
-	var generateCalled bool
-
-	mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch {
-		case r.URL.Path == "/api/show" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ShowResponse{
-				Capabilities: []model.Capability{model.CapabilityCompletion},
-				RemoteModel:  "gpt-oss:20b",
-			}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/tags" && r.Method == http.MethodGet:
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.ListResponse{Models: nil}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/pull" && r.Method == http.MethodPost:
-			w.WriteHeader(http.StatusInternalServerError)
-			if err := json.NewEncoder(w).Encode(map[string]string{"error": "pull failed"}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		case r.URL.Path == "/api/generate" && r.Method == http.MethodPost:
-			generateCalled = true
-			w.WriteHeader(http.StatusOK)
-			if err := json.NewEncoder(w).Encode(api.GenerateResponse{Done: true}); err != nil {
-				http.Error(w, err.Error(), http.StatusInternalServerError)
-			}
-			return
-		default:
-			http.NotFound(w, r)
-		}
-	}))
-
-	t.Setenv("OLLAMA_HOST", mockServer.URL)
-	t.Cleanup(mockServer.Close)
-
-	cmd := &cobra.Command{}
-	cmd.SetContext(t.Context())
-	cmd.Flags().String("keepalive", "", "")
-	cmd.Flags().Bool("truncate", false, "")
-	cmd.Flags().Int("dimensions", 0, "")
-	cmd.Flags().Bool("verbose", false, "")
-	cmd.Flags().Bool("insecure", false, "")
-	cmd.Flags().Bool("nowordwrap", false, "")
-	cmd.Flags().String("format", "", "")
-	cmd.Flags().String("think", "", "")
-	cmd.Flags().Bool("hidethinking", false, "")
-
-	err := RunHandler(cmd, []string{"gpt-oss:20b:cloud", "hi"})
-	if err != nil {
-		t.Fatalf("RunHandler returned error: %v", err)
-	}
-
-	if !generateCalled {
-		t.Fatal("expected /api/generate to be called despite pull failure")
-	}
-}
-
 func TestGetModelfileName(t *testing.T) {
 	tests := []struct {
 		name          string
@@ -1525,87 +1176,6 @@ func TestCreateHandler(t *testing.T) {
 	}
 }

-func TestCreateHandlerDraftQuantizeRequiresExperimental(t *testing.T) {
-	cmd := &cobra.Command{}
-	cmd.Flags().Bool("experimental", false, "")
-	cmd.Flags().String("draft-quantize", "mxfp8", "")
-	cmd.SetContext(t.Context())
-
-	err := CreateHandler(cmd, []string{"test-model"})
-	if err == nil || !strings.Contains(err.Error(), "--draft-quantize requires --experimental") {
-		t.Fatalf("error = %v, want draft-quantize requires experimental", err)
-	}
-}
-
-func TestCreateHandlerDraftRequiresExperimental(t *testing.T) {
-	dir := t.TempDir()
-	modelfile := filepath.Join(dir, "Modelfile")
-	if err := os.WriteFile(modelfile, []byte("FROM base\nDRAFT ./assistant\n"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	cmd := &cobra.Command{}
-	cmd.Flags().Bool("experimental", false, "")
-	cmd.Flags().String("draft-quantize", "", "")
-	cmd.Flags().String("file", modelfile, "")
-	cmd.SetContext(t.Context())
-
-	err := CreateHandler(cmd, []string{"test-model"})
-	if err == nil || !strings.Contains(err.Error(), "DRAFT requires --experimental") {
-		t.Fatalf("error = %v, want DRAFT requires --experimental", err)
-	}
-}
-
-func TestResolveExperimentalLocalModelDir(t *testing.T) {
-	dir := t.TempDir()
-	modelfile := filepath.Join(dir, "Modelfile")
-	modelDir := filepath.Join(dir, "model")
-	if err := os.Mkdir(modelDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(modelDir, "config.json"), []byte(`{}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(modelDir, "model.safetensors"), []byte("dummy"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	if got := resolveExperimentalLocalModelDir("gemma4", modelfile); got != "gemma4" {
-		t.Fatalf("resolveExperimentalLocalModelDir(model name) = %q, want gemma4", got)
-	}
-	if got := resolveExperimentalLocalModelDir("./model", modelfile); got != modelDir {
-		t.Fatalf("resolveExperimentalLocalModelDir(local dir) = %q, want %q", got, modelDir)
-	}
-}
-
-func TestResolveExperimentalDraftDir(t *testing.T) {
-	dir := t.TempDir()
-	modelfile := filepath.Join(dir, "Modelfile")
-	draftDir := filepath.Join(dir, "assistant")
-	if err := os.Mkdir(draftDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(draftDir, "config.json"), []byte(`{}`), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(draftDir, "model.safetensors"), []byte("dummy"), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	got, err := resolveExperimentalDraftDir("./assistant", modelfile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if got != draftDir {
-		t.Fatalf("resolveExperimentalDraftDir(local dir) = %q, want %q", got, draftDir)
-	}
-
-	_, err = resolveExperimentalDraftDir("assistant-model", modelfile)
-	if err == nil || !strings.Contains(err.Error(), "DRAFT model references are not supported with --experimental yet") {
-		t.Fatalf("error = %v, want unsupported draft model reference", err)
-	}
-}
-
 func TestNewCreateRequest(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -1642,20 +1212,6 @@ func TestNewCreateRequest(t *testing.T) {
 				Model: "newmodel",
 			},
 		},
-		{
-			"explicit cloud model preserves source when parent lacks it",
-			"newmodel",
-			runOptions{
-				Model:       "qwen3.5:cloud",
-				ParentModel: "qwen3.5",
-				Messages:    []api.Message{},
-				WordWrap:    true,
-			},
-			&api.CreateRequest{
-				From:  "qwen3.5:cloud",
-				Model: "newmodel",
-			},
-		},
 		{
 			"parent model as filepath test",
 			"newmodel",
@@ -1737,24 +1293,6 @@ func TestNewCreateRequest(t *testing.T) {
 				},
 			},
 		},
-		{
-			"loaded messages are preserved when saving",
-			"newmodel",
-			runOptions{
-				Model:          "mymodel",
-				ParentModel:    "parentmodel",
-				LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded"}},
-				Messages:       []api.Message{{Role: "user", Content: "new"}},
-			},
-			&api.CreateRequest{
-				From:  "parentmodel",
-				Model: "newmodel",
-				Messages: []api.Message{
-					{Role: "assistant", Content: "loaded"},
-					{Role: "user", Content: "new"},
-				},
-			},
-		},
 	}

 	for _, tt := range tests {
@@ -1767,43 +1305,15 @@ func TestNewCreateRequest(t *testing.T) {
 	}
 }

-func TestApplyShowResponseToRunOptions(t *testing.T) {
-	opts := runOptions{}
-	info := &api.ShowResponse{
-		Details: api.ModelDetails{
-			ParentModel: "parentmodel",
-		},
-		Messages: []api.Message{
-			{Role: "assistant", Content: "loaded"},
-		},
-	}
-
-	applyShowResponseToRunOptions(&opts, info)
-
-	if opts.ParentModel != "parentmodel" {
-		t.Fatalf("ParentModel = %q, want %q", opts.ParentModel, "parentmodel")
-	}
-
-	if !cmp.Equal(opts.LoadedMessages, info.Messages) {
-		t.Fatalf("LoadedMessages = %#v, want %#v", opts.LoadedMessages, info.Messages)
-	}
-
-	info.Messages[0].Content = "modified"
-	if opts.LoadedMessages[0].Content == "modified" {
-		t.Fatal("LoadedMessages should be copied independently from ShowResponse")
-	}
-}
-
 func TestRunOptions_Copy(t *testing.T) {
 	// Setup test data
 	originalKeepAlive := &api.Duration{Duration: 5 * time.Minute}
 	originalThink := &api.ThinkValue{Value: "test reasoning"}

 	original := runOptions{
-		Model:          "test-model",
-		ParentModel:    "parent-model",
-		LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded hello"}},
-		Prompt:         "test prompt",
+		Model:       "test-model",
+		ParentModel: "parent-model",
+		Prompt:      "test prompt",
 		Messages: []api.Message{
 			{Role: "user", Content: "hello"},
 			{Role: "assistant", Content: "hi there"},
@@ -1843,7 +1353,6 @@ func TestRunOptions_Copy(t *testing.T) {
 	}{
 		{"Model", copied.Model, original.Model},
 		{"ParentModel", copied.ParentModel, original.ParentModel},
-		{"LoadedMessages", copied.LoadedMessages, original.LoadedMessages},
 		{"Prompt", copied.Prompt, original.Prompt},
 		{"WordWrap", copied.WordWrap, original.WordWrap},
 		{"Format", copied.Format, original.Format},
@@ -1948,18 +1457,13 @@ func TestRunOptions_Copy(t *testing.T) {
 func TestRunOptions_Copy_EmptySlicesAndMaps(t *testing.T) {
 	// Test with empty slices and maps
 	original := runOptions{
-		LoadedMessages: []api.Message{},
-		Messages:       []api.Message{},
-		Images:         []api.ImageData{},
-		Options:        map[string]any{},
+		Messages: []api.Message{},
+		Images:   []api.ImageData{},
+		Options:  map[string]any{},
 	}

 	copied := original.Copy()

-	if copied.LoadedMessages == nil {
-		t.Error("Empty LoadedMessages slice should remain empty, not nil")
-	}
-
 	if copied.Messages == nil {
 		t.Error("Empty Messages slice should remain empty, not nil")
 	}
@@ -1976,10 +1480,6 @@ func TestRunOptions_Copy_EmptySlicesAndMaps(t *testing.T) {
 		t.Error("Empty Messages slice should remain empty")
 	}

-	if len(copied.LoadedMessages) != 0 {
-		t.Error("Empty LoadedMessages slice should remain empty")
-	}
-
 	if len(copied.Images) != 0 {
 		t.Error("Empty Images slice should remain empty")
 	}
@@ -2057,7 +1557,7 @@ func TestShowInfoImageGen(t *testing.T) {
 			QuantizationLevel: "Q8",
 		},
 		Capabilities: []model.Capability{model.CapabilityImage},
-		Requires:     "0.19.0",
+		Requires:     "0.14.0",
 	}, false, &b)
 	if err != nil {
 		t.Fatal(err)
@@ -2067,7 +1567,7 @@ func TestShowInfoImageGen(t *testing.T) {
 		"    architecture    ZImagePipeline    \n" +
 		"    parameters      10.3B             \n" +
 		"    quantization    Q8                \n" +
-		"    requires        0.19.0            \n" +
+		"    requires        0.14.0            \n" +
 		"\n" +
 		"  Capabilities\n" +
 		"    image    \n" +
@@ -2125,20 +1625,16 @@ func TestRunOptions_Copy_Independence(t *testing.T) {
 	// Test that modifications to original don't affect copy
 	originalThink := &api.ThinkValue{Value: "original"}
 	original := runOptions{
-		Model:          "original-model",
-		LoadedMessages: []api.Message{{Role: "assistant", Content: "loaded"}},
-		Messages:       []api.Message{{Role: "user", Content: "original"}},
-		Options:        map[string]any{"key": "value"},
-		Think:          originalThink,
+		Model:    "original-model",
+		Messages: []api.Message{{Role: "user", Content: "original"}},
+		Options:  map[string]any{"key": "value"},
+		Think:    originalThink,
 	}

 	copied := original.Copy()

 	// Modify original
 	original.Model = "modified-model"
-	if len(original.LoadedMessages) > 0 {
-		original.LoadedMessages[0].Content = "modified loaded"
-	}
 	if len(original.Messages) > 0 {
 		original.Messages[0].Content = "modified"
 	}
@@ -2152,10 +1648,6 @@ func TestRunOptions_Copy_Independence(t *testing.T) {
 		t.Error("Copy Model should not be affected by original modification")
 	}

-	if len(copied.LoadedMessages) > 0 && copied.LoadedMessages[0].Content == "modified loaded" {
-		t.Error("Copy LoadedMessages should not be affected by original modification")
-	}
-
 	if len(copied.Messages) > 0 && copied.Messages[0].Content == "modified" {
 		t.Error("Copy Messages should not be affected by original modification")
 	}
@@ -2171,81 +1663,31 @@ func TestRunOptions_Copy_Independence(t *testing.T) {

 func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 	tests := []struct {
-		name            string
-		model           string
-		showStatus      int
-		remoteHost      string
-		remoteModel     string
-		whoamiStatus    int
-		whoamiResp      any
-		expectWhoami    bool
-		expectedError   string
-		expectAuthError bool
+		name          string
+		remoteHost    string
+		whoamiStatus  int
+		whoamiResp    any
+		expectedError string
 	}{
 		{
 			name:         "ollama.com cloud model - user signed in",
-			model:        "test-cloud-model",
 			remoteHost:   "https://ollama.com",
-			remoteModel:  "test-model",
 			whoamiStatus: http.StatusOK,
 			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
 		},
 		{
 			name:         "ollama.com cloud model - user not signed in",
-			model:        "test-cloud-model",
 			remoteHost:   "https://ollama.com",
-			remoteModel:  "test-model",
 			whoamiStatus: http.StatusUnauthorized,
 			whoamiResp: map[string]string{
 				"error":      "unauthorized",
 				"signin_url": "https://ollama.com/signin",
 			},
-			expectWhoami:    true,
-			expectedError:   "unauthorized",
-			expectAuthError: true,
+			expectedError: "unauthorized",
 		},
 		{
 			name:         "non-ollama.com remote - no auth check",
-			model:        "test-cloud-model",
 			remoteHost:   "https://other-remote.com",
-			remoteModel:  "test-model",
-			whoamiStatus: http.StatusUnauthorized, // should not be called
-			whoamiResp:   nil,
-		},
-		{
-			name:         "explicit :cloud model - auth check without remote metadata",
-			model:        "kimi-k2.5:cloud",
-			remoteHost:   "",
-			remoteModel:  "",
-			whoamiStatus: http.StatusOK,
-			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
-		},
-		{
-			name:            "explicit :cloud model without local stub returns not found by default",
-			model:           "minimax-m2.7:cloud",
-			showStatus:      http.StatusNotFound,
-			whoamiStatus:    http.StatusOK,
-			whoamiResp:      api.UserResponse{Name: "testuser"},
-			expectedError:   "not found",
-			expectWhoami:    false,
-			expectAuthError: false,
-		},
-		{
-			name:         "explicit -cloud model - auth check without remote metadata",
-			model:        "kimi-k2.5:latest-cloud",
-			remoteHost:   "",
-			remoteModel:  "",
-			whoamiStatus: http.StatusOK,
-			whoamiResp:   api.UserResponse{Name: "testuser"},
-			expectWhoami: true,
-		},
-		{
-			name:         "dash cloud-like name without explicit source does not require auth",
-			model:        "test-cloud-model",
-			remoteHost:   "",
-			remoteModel:  "",
 			whoamiStatus: http.StatusUnauthorized, // should not be called
 			whoamiResp:   nil,
 		},
@@ -2257,15 +1699,10 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 			mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				switch r.URL.Path {
 				case "/api/show":
-					if tt.showStatus != 0 && tt.showStatus != http.StatusOK {
-						w.WriteHeader(tt.showStatus)
-						_ = json.NewEncoder(w).Encode(map[string]string{"error": "not found"})
-						return
-					}
 					w.Header().Set("Content-Type", "application/json")
 					if err := json.NewEncoder(w).Encode(api.ShowResponse{
 						RemoteHost:  tt.remoteHost,
-						RemoteModel: tt.remoteModel,
+						RemoteModel: "test-model",
 					}); err != nil {
 						http.Error(w, err.Error(), http.StatusInternalServerError)
 					}
@@ -2278,8 +1715,6 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 							http.Error(w, err.Error(), http.StatusInternalServerError)
 						}
 					}
-				case "/api/generate":
-					w.WriteHeader(http.StatusOK)
 				default:
 					http.NotFound(w, r)
 				}
@@ -2292,28 +1727,29 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 			cmd.SetContext(t.Context())

 			opts := &runOptions{
-				Model:       tt.model,
+				Model:       "test-cloud-model",
 				ShowConnect: false,
 			}

 			err := loadOrUnloadModel(cmd, opts)

-			if whoamiCalled != tt.expectWhoami {
-				t.Errorf("whoami called = %v, want %v", whoamiCalled, tt.expectWhoami)
+			if strings.HasPrefix(tt.remoteHost, "https://ollama.com") {
+				if !whoamiCalled {
+					t.Error("expected whoami to be called for ollama.com cloud model")
+				}
+			} else {
+				if whoamiCalled {
+					t.Error("whoami should not be called for non-ollama.com remote")
+				}
 			}

 			if tt.expectedError != "" {
 				if err == nil {
 					t.Errorf("expected error containing %q, got nil", tt.expectedError)
 				} else {
-					if !tt.expectAuthError && !strings.Contains(strings.ToLower(err.Error()), strings.ToLower(tt.expectedError)) {
-						t.Errorf("expected error containing %q, got %v", tt.expectedError, err)
-					}
-					if tt.expectAuthError {
-						var authErr api.AuthorizationError
-						if !errors.As(err, &authErr) {
-							t.Errorf("expected AuthorizationError, got %T: %v", err, err)
-						}
+					var authErr api.AuthorizationError
+					if !errors.As(err, &authErr) {
+						t.Errorf("expected AuthorizationError, got %T: %v", err, err)
 					}
 				}
 			} else {
@@ -2324,38 +1760,3 @@ func TestLoadOrUnloadModel_CloudModelAuth(t *testing.T) {
 		})
 	}
 }
-
-func TestIsLocalhost(t *testing.T) {
-	tests := []struct {
-		name     string
-		host     string
-		expected bool
-	}{
-		{"default empty", "", true},
-		{"localhost no port", "localhost", true},
-		{"localhost with port", "localhost:11435", true},
-		{"127.0.0.1 no port", "127.0.0.1", true},
-		{"127.0.0.1 with port", "127.0.0.1:11434", true},
-		{"0.0.0.0 no port", "0.0.0.0", true},
-		{"0.0.0.0 with port", "0.0.0.0:11434", true},
-		{"::1 no port", "::1", true},
-		{"[::1] with port", "[::1]:11434", true},
-		{"loopback with scheme", "http://localhost:11434", true},
-		{"remote hostname", "example.com", false},
-		{"remote hostname with port", "example.com:11434", false},
-		{"remote IP", "192.168.1.1", false},
-		{"remote IP with port", "192.168.1.1:11434", false},
-		{"remote with scheme", "http://example.com:11434", false},
-		{"https remote", "https://example.com:443", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Setenv("OLLAMA_HOST", tt.host)
-			got := isLocalhost()
-			if got != tt.expected {
-				t.Errorf("isLocalhost() with OLLAMA_HOST=%q = %v, want %v", tt.host, got, tt.expected)
-			}
-		})
-	}
-}
@@ -0,0 +1,192 @@
+package config
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+)
+
+// Claude implements Runner and AliasConfigurer for Claude Code integration
+type Claude struct{}
+
+// Compile-time check that Claude implements AliasConfigurer
+var _ AliasConfigurer = (*Claude)(nil)
+
+func (c *Claude) String() string { return "Claude Code" }
+
+func (c *Claude) args(model string, extra []string) []string {
+	var args []string
+	if model != "" {
+		args = append(args, "--model", model)
+	}
+	args = append(args, extra...)
+	return args
+}
+
+func (c *Claude) findPath() (string, error) {
+	if p, err := exec.LookPath("claude"); err == nil {
+		return p, nil
+	}
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	name := "claude"
+	if runtime.GOOS == "windows" {
+		name = "claude.exe"
+	}
+	fallback := filepath.Join(home, ".claude", "local", name)
+	if _, err := os.Stat(fallback); err != nil {
+		return "", err
+	}
+	return fallback, nil
+}
+
+func (c *Claude) Run(model string, args []string) error {
+	claudePath, err := c.findPath()
+	if err != nil {
+		return fmt.Errorf("claude is not installed, install from https://code.claude.com/docs/en/quickstart")
+	}
+
+	cmd := exec.Command(claudePath, c.args(model, args)...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	env := append(os.Environ(),
+		"ANTHROPIC_BASE_URL="+envconfig.Host().String(),
+		"ANTHROPIC_API_KEY=",
+		"ANTHROPIC_AUTH_TOKEN=ollama",
+	)
+
+	env = append(env, c.modelEnvVars(model)...)
+
+	cmd.Env = env
+	return cmd.Run()
+}
+
+// modelEnvVars returns Claude Code env vars that route all model tiers through Ollama.
+func (c *Claude) modelEnvVars(model string) []string {
+	primary := model
+	fast := model
+	if cfg, err := loadIntegration("claude"); err == nil && cfg.Aliases != nil {
+		if p := cfg.Aliases["primary"]; p != "" {
+			primary = p
+		}
+		if f := cfg.Aliases["fast"]; f != "" {
+			fast = f
+		}
+	}
+	return []string{
+		"ANTHROPIC_DEFAULT_OPUS_MODEL=" + primary,
+		"ANTHROPIC_DEFAULT_SONNET_MODEL=" + primary,
+		"ANTHROPIC_DEFAULT_HAIKU_MODEL=" + fast,
+		"CLAUDE_CODE_SUBAGENT_MODEL=" + primary,
+	}
+}
+
+// ConfigureAliases sets up model aliases for Claude Code.
+// model: the model to use (if empty, user will be prompted to select)
+// aliases: existing alias configuration to preserve/update
+// Cloud-only: subagent routing (fast model) is gated to cloud models only until
+// there is a better strategy for prompt caching on local models.
+func (c *Claude) ConfigureAliases(ctx context.Context, model string, existingAliases map[string]string, force bool) (map[string]string, bool, error) {
+	aliases := make(map[string]string)
+	for k, v := range existingAliases {
+		aliases[k] = v
+	}
+
+	if model != "" {
+		aliases["primary"] = model
+	}
+
+	if !force && aliases["primary"] != "" {
+		client, _ := api.ClientFromEnvironment()
+		if isCloudModel(ctx, client, aliases["primary"]) {
+			if isCloudModel(ctx, client, aliases["fast"]) {
+				return aliases, false, nil
+			}
+		} else {
+			delete(aliases, "fast")
+			return aliases, false, nil
+		}
+	}
+
+	items, existingModels, cloudModels, client, err := listModels(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+
+	fmt.Fprintf(os.Stderr, "\n%sModel Configuration%s\n\n", ansiBold, ansiReset)
+
+	if aliases["primary"] == "" || force {
+		primary, err := DefaultSingleSelector("Select model:", items, aliases["primary"])
+		if err != nil {
+			return nil, false, err
+		}
+		if err := pullIfNeeded(ctx, client, existingModels, primary); err != nil {
+			return nil, false, err
+		}
+		if err := ensureAuth(ctx, client, cloudModels, []string{primary}); err != nil {
+			return nil, false, err
+		}
+		aliases["primary"] = primary
+	}
+
+	if isCloudModel(ctx, client, aliases["primary"]) {
+		if aliases["fast"] == "" || !isCloudModel(ctx, client, aliases["fast"]) {
+			aliases["fast"] = aliases["primary"]
+		}
+	} else {
+		delete(aliases, "fast")
+	}
+
+	return aliases, true, nil
+}
+
+// SetAliases syncs the configured aliases to the Ollama server using prefix matching.
+// Cloud-only: for local models (fast is empty), we delete any existing aliases to
+// prevent stale routing to a previous cloud model.
+func (c *Claude) SetAliases(ctx context.Context, aliases map[string]string) error {
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return err
+	}
+
+	prefixes := []string{"claude-sonnet-", "claude-haiku-"}
+
+	if aliases["fast"] == "" {
+		for _, prefix := range prefixes {
+			_ = client.DeleteAliasExperimental(ctx, &api.AliasDeleteRequest{Alias: prefix})
+		}
+		return nil
+	}
+
+	prefixAliases := map[string]string{
+		"claude-sonnet-": aliases["primary"],
+		"claude-haiku-":  aliases["fast"],
+	}
+
+	var errs []string
+	for prefix, target := range prefixAliases {
+		req := &api.AliasRequest{
+			Alias:          prefix,
+			Target:         target,
+			PrefixMatching: true,
+		}
+		if err := client.SetAliasExperimental(ctx, req); err != nil {
+			errs = append(errs, prefix)
+		}
+	}
+
+	if len(errs) > 0 {
+		return fmt.Errorf("failed to set aliases: %v", errs)
+	}
+	return nil
+}
@@ -1,4 +1,4 @@
-package launch
+package config

 import (
 	"os"
@@ -117,7 +117,10 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		return m
 	}

-	t.Run("maps all Claude model env vars to the provided model", func(t *testing.T) {
+	t.Run("falls back to model param when no aliases saved", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
 		got := envMap(c.modelEnvVars("llama3.2"))
 		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "llama3.2" {
 			t.Errorf("OPUS = %q, want llama3.2", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
@@ -131,41 +134,65 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "llama3.2" {
 			t.Errorf("SUBAGENT = %q, want llama3.2", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty for local models", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+	})
+
+	t.Run("uses primary alias for opus sonnet and subagent", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
+		SaveIntegration("claude", []string{"qwen3:8b"})
+		saveAliases("claude", map[string]string{"primary": "qwen3:8b"})
+
+		got := envMap(c.modelEnvVars("qwen3:8b"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "qwen3:8b" {
+			t.Errorf("OPUS = %q, want qwen3:8b", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
+		}
+		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "qwen3:8b" {
+			t.Errorf("SONNET = %q, want qwen3:8b", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
+		}
+		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "qwen3:8b" {
+			t.Errorf("HAIKU = %q, want qwen3:8b (no fast alias)", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
+		}
+		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "qwen3:8b" {
+			t.Errorf("SUBAGENT = %q, want qwen3:8b", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
 	})

-	t.Run("supports empty model", func(t *testing.T) {
-		got := envMap(c.modelEnvVars(""))
-		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "" {
-			t.Errorf("OPUS = %q, want empty", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
+	t.Run("uses fast alias for haiku", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)
+
+		SaveIntegration("claude", []string{"llama3.2:70b"})
+		saveAliases("claude", map[string]string{
+			"primary": "llama3.2:70b",
+			"fast":    "llama3.2:8b",
+		})
+
+		got := envMap(c.modelEnvVars("llama3.2:70b"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "llama3.2:70b" {
+			t.Errorf("OPUS = %q, want llama3.2:70b", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
 		}
-		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "" {
-			t.Errorf("SONNET = %q, want empty", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
+		if got["ANTHROPIC_DEFAULT_SONNET_MODEL"] != "llama3.2:70b" {
+			t.Errorf("SONNET = %q, want llama3.2:70b", got["ANTHROPIC_DEFAULT_SONNET_MODEL"])
 		}
-		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "" {
-			t.Errorf("HAIKU = %q, want empty", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
+		if got["ANTHROPIC_DEFAULT_HAIKU_MODEL"] != "llama3.2:8b" {
+			t.Errorf("HAIKU = %q, want llama3.2:8b", got["ANTHROPIC_DEFAULT_HAIKU_MODEL"])
 		}
-		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "" {
-			t.Errorf("SUBAGENT = %q, want empty", got["CLAUDE_CODE_SUBAGENT_MODEL"])
-		}
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+		if got["CLAUDE_CODE_SUBAGENT_MODEL"] != "llama3.2:70b" {
+			t.Errorf("SUBAGENT = %q, want llama3.2:70b", got["CLAUDE_CODE_SUBAGENT_MODEL"])
 		}
 	})

-	t.Run("sets auto compact window for known cloud models", func(t *testing.T) {
-		got := envMap(c.modelEnvVars("glm-5:cloud"))
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "202752" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want 202752", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
-		}
-	})
+	t.Run("alias primary overrides model param", func(t *testing.T) {
+		tmpDir := t.TempDir()
+		setTestHome(t, tmpDir)

-	t.Run("does not set auto compact window for unknown cloud models", func(t *testing.T) {
-		got := envMap(c.modelEnvVars("unknown-model:cloud"))
-		if got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"] != "" {
-			t.Errorf("AUTO_COMPACT_WINDOW = %q, want empty", got["CLAUDE_CODE_AUTO_COMPACT_WINDOW"])
+		SaveIntegration("claude", []string{"saved-model"})
+		saveAliases("claude", map[string]string{"primary": "saved-model"})
+
+		got := envMap(c.modelEnvVars("different-model"))
+		if got["ANTHROPIC_DEFAULT_OPUS_MODEL"] != "saved-model" {
+			t.Errorf("OPUS = %q, want saved-model", got["ANTHROPIC_DEFAULT_OPUS_MODEL"])
 		}
 	})
 }
@@ -1,13 +1,14 @@
-package launch
+package config

 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
 	"github.com/ollama/ollama/envconfig"
 )

@@ -16,11 +17,29 @@ type Cline struct{}

 func (c *Cline) String() string { return "Cline" }

-func (c *Cline) Run(model string, _ []LaunchModel, args []string) error {
+func (c *Cline) Run(model string, args []string) error {
 	if _, err := exec.LookPath("cline"); err != nil {
 		return fmt.Errorf("cline is not installed, install with: npm install -g cline")
 	}

+	models := []string{model}
+	if config, err := loadIntegration("cline"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	var err error
+	models, err = resolveEditorModels("cline", models, func() ([]string, error) {
+		return selectModels(context.Background(), "cline", "")
+	})
+	if errors.Is(err, errCancelled) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	if err := c.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
 	cmd := exec.Command("cline", args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -40,7 +59,7 @@ func (c *Cline) Paths() []string {
 	return nil
 }

-func (c *Cline) Edit(models []LaunchModel) error {
+func (c *Cline) Edit(models []string) error {
 	if len(models) == 0 {
 		return nil
 	}
@@ -66,10 +85,10 @@ func (c *Cline) Edit(models []LaunchModel) error {
 	baseURL := envconfig.Host().String()
 	config["ollamaBaseUrl"] = baseURL
 	config["actModeApiProvider"] = "ollama"
-	config["actModeOllamaModelId"] = models[0].Name
+	config["actModeOllamaModelId"] = models[0]
 	config["actModeOllamaBaseUrl"] = baseURL
 	config["planModeApiProvider"] = "ollama"
-	config["planModeOllamaModelId"] = models[0].Name
+	config["planModeOllamaModelId"] = models[0]
 	config["planModeOllamaBaseUrl"] = baseURL

 	config["welcomeViewCompleted"] = true
@@ -78,7 +97,7 @@ func (c *Cline) Edit(models []LaunchModel) error {
 	if err != nil {
 		return err
 	}
-	return fileutil.WriteWithBackup(configPath, data, "cline")
+	return writeWithBackup(configPath, data)
 }

 func (c *Cline) Models() []string {
@@ -87,7 +106,7 @@ func (c *Cline) Models() []string {
 		return nil
 	}

-	config, err := fileutil.ReadJSON(filepath.Join(home, ".cline", "data", "globalState.json"))
+	config, err := readJSONFile(filepath.Join(home, ".cline", "data", "globalState.json"))
 	if err != nil {
 		return nil
 	}
@@ -1,4 +1,4 @@
-package launch
+package config

 import (
 	"encoding/json"
@@ -43,7 +43,7 @@ func TestClineEdit(t *testing.T) {
 	t.Run("creates config from scratch", func(t *testing.T) {
 		os.RemoveAll(filepath.Join(tmpDir, ".cline"))

-		if err := c.Edit(testLaunchModels("kimi-k2.5:cloud")); err != nil {
+		if err := c.Edit([]string{"kimi-k2.5:cloud"}); err != nil {
 			t.Fatal(err)
 		}

@@ -77,7 +77,7 @@ func TestClineEdit(t *testing.T) {
 		data, _ := json.Marshal(existing)
 		os.WriteFile(configPath, data, 0o644)

-		if err := c.Edit(testLaunchModels("glm-5:cloud")); err != nil {
+		if err := c.Edit([]string{"glm-5:cloud"}); err != nil {
 			t.Fatal(err)
 		}

@@ -93,10 +93,10 @@ func TestClineEdit(t *testing.T) {
 	t.Run("updates model on re-edit", func(t *testing.T) {
 		os.RemoveAll(filepath.Join(tmpDir, ".cline"))

-		if err := c.Edit(testLaunchModels("kimi-k2.5:cloud")); err != nil {
+		if err := c.Edit([]string{"kimi-k2.5:cloud"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := c.Edit(testLaunchModels("glm-5:cloud")); err != nil {
+		if err := c.Edit([]string{"glm-5:cloud"}); err != nil {
 			t.Fatal(err)
 		}

@@ -124,7 +124,7 @@ func TestClineEdit(t *testing.T) {
 	t.Run("uses first model as primary", func(t *testing.T) {
 		os.RemoveAll(filepath.Join(tmpDir, ".cline"))

-		if err := c.Edit(testLaunchModels("kimi-k2.5:cloud", "glm-5:cloud")); err != nil {
+		if err := c.Edit([]string{"kimi-k2.5:cloud", "glm-5:cloud"}); err != nil {
 			t.Fatal(err)
 		}

@@ -0,0 +1,67 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+
+	"github.com/ollama/ollama/envconfig"
+	"golang.org/x/mod/semver"
+)
+
+// Codex implements Runner for Codex integration
+type Codex struct{}
+
+func (c *Codex) String() string { return "Codex" }
+
+func (c *Codex) args(model string, extra []string) []string {
+	args := []string{"--oss"}
+	if model != "" {
+		args = append(args, "-m", model)
+	}
+	args = append(args, extra...)
+	return args
+}
+
+func (c *Codex) Run(model string, args []string) error {
+	if err := checkCodexVersion(); err != nil {
+		return err
+	}
+
+	cmd := exec.Command("codex", c.args(model, args)...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	cmd.Env = append(os.Environ(),
+		"OPENAI_BASE_URL="+envconfig.Host().String()+"/v1/",
+		"OPENAI_API_KEY=ollama",
+	)
+	return cmd.Run()
+}
+
+func checkCodexVersion() error {
+	if _, err := exec.LookPath("codex"); err != nil {
+		return fmt.Errorf("codex is not installed, install with: npm install -g @openai/codex")
+	}
+
+	out, err := exec.Command("codex", "--version").Output()
+	if err != nil {
+		return fmt.Errorf("failed to get codex version: %w", err)
+	}
+
+	// Parse output like "codex-cli 0.87.0"
+	fields := strings.Fields(strings.TrimSpace(string(out)))
+	if len(fields) < 2 {
+		return fmt.Errorf("unexpected codex version output: %s", string(out))
+	}
+
+	version := "v" + fields[len(fields)-1]
+	minVersion := "v0.81.0"
+
+	if semver.Compare(version, minVersion) < 0 {
+		return fmt.Errorf("codex version %s is too old, minimum required is %s, update with: npm update -g @openai/codex", fields[len(fields)-1], "0.81.0")
+	}
+
+	return nil
+}
@@ -0,0 +1,31 @@
+package config
+
+import (
+	"slices"
+	"testing"
+)
+
+func TestCodexArgs(t *testing.T) {
+	c := &Codex{}
+
+	tests := []struct {
+		name  string
+		model string
+		args  []string
+		want  []string
+	}{
+		{"with model", "llama3.2", nil, []string{"--oss", "-m", "llama3.2"}},
+		{"empty model", "", nil, []string{"--oss"}},
+		{"with model and profile", "qwen3-coder", []string{"-p", "myprofile"}, []string{"--oss", "-m", "qwen3-coder", "-p", "myprofile"}},
+		{"with sandbox flag", "llama3.2", []string{"--sandbox", "workspace-write"}, []string{"--oss", "-m", "llama3.2", "--sandbox", "workspace-write"}},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := c.args(tt.model, tt.args)
+			if !slices.Equal(got, tt.want) {
+				t.Errorf("args(%q, %v) = %v, want %v", tt.model, tt.args, got, tt.want)
+			}
+		})
+	}
+}
@@ -3,6 +3,7 @@
 package config

 import (
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -10,7 +11,7 @@ import (
 	"path/filepath"
 	"strings"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/api"
 )

 type integration struct {
@@ -19,9 +20,6 @@ type integration struct {
 	Onboarded bool              `json:"onboarded,omitempty"`
 }

-// IntegrationConfig is the persisted config for one integration.
-type IntegrationConfig = integration
-
 type config struct {
 	Integrations  map[string]*integration `json:"integrations"`
 	LastModel     string                  `json:"last_model,omitempty"`
@@ -126,7 +124,7 @@ func save(cfg *config) error {
 		return err
 	}

-	return fileutil.WriteWithBackup(path, data)
+	return writeWithBackup(path, data)
 }

 func SaveIntegration(appName string, models []string) error {
@@ -157,8 +155,8 @@ func SaveIntegration(appName string, models []string) error {
 	return save(cfg)
 }

-// MarkIntegrationOnboarded marks an integration as onboarded in Ollama's config.
-func MarkIntegrationOnboarded(appName string) error {
+// integrationOnboarded marks an integration as onboarded in ollama's config.
+func integrationOnboarded(appName string) error {
 	cfg, err := load()
 	if err != nil {
 		return err
@@ -176,7 +174,7 @@ func MarkIntegrationOnboarded(appName string) error {

 // IntegrationModel returns the first configured model for an integration, or empty string if not configured.
 func IntegrationModel(appName string) string {
-	integrationConfig, err := LoadIntegration(appName)
+	integrationConfig, err := loadIntegration(appName)
 	if err != nil || len(integrationConfig.Models) == 0 {
 		return ""
 	}
@@ -185,7 +183,7 @@ func IntegrationModel(appName string) string {

 // IntegrationModels returns all configured models for an integration, or nil.
 func IntegrationModels(appName string) []string {
-	integrationConfig, err := LoadIntegration(appName)
+	integrationConfig, err := loadIntegration(appName)
 	if err != nil || len(integrationConfig.Models) == 0 {
 		return nil
 	}
@@ -230,8 +228,28 @@ func SetLastSelection(selection string) error {
 	return save(cfg)
 }

-// LoadIntegration returns the saved config for one integration.
-func LoadIntegration(appName string) (*integration, error) {
+// ModelExists checks if a model exists on the Ollama server.
+func ModelExists(ctx context.Context, name string) bool {
+	if name == "" {
+		return false
+	}
+	client, err := api.ClientFromEnvironment()
+	if err != nil {
+		return false
+	}
+	models, err := client.List(ctx)
+	if err != nil {
+		return false
+	}
+	for _, m := range models.Models {
+		if m.Name == name || strings.HasPrefix(m.Name, name+":") {
+			return true
+		}
+	}
+	return false
+}
+
+func loadIntegration(appName string) (*integration, error) {
 	cfg, err := load()
 	if err != nil {
 		return nil, err
@@ -245,8 +263,7 @@ func LoadIntegration(appName string) (*integration, error) {
 	return integrationConfig, nil
 }

-// SaveAliases replaces the saved aliases for one integration.
-func SaveAliases(appName string, aliases map[string]string) error {
+func saveAliases(appName string, aliases map[string]string) error {
 	if appName == "" {
 		return errors.New("app name cannot be empty")
 	}
@@ -1,6 +1,7 @@
 package config

 import (
+	"context"
 	"errors"
 	"os"
 	"path/filepath"
@@ -44,12 +45,12 @@ func TestSaveAliases_ReplacesNotMerges(t *testing.T) {
 		"primary": "cloud-model",
 		"fast":    "cloud-model",
 	}
-	if err := SaveAliases("claude", initial); err != nil {
+	if err := saveAliases("claude", initial); err != nil {
 		t.Fatalf("failed to save initial aliases: %v", err)
 	}

 	// Verify both are saved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -62,12 +63,12 @@ func TestSaveAliases_ReplacesNotMerges(t *testing.T) {
 		"primary": "local-model",
 		// fast intentionally missing
 	}
-	if err := SaveAliases("claude", updated); err != nil {
+	if err := saveAliases("claude", updated); err != nil {
 		t.Fatalf("failed to save updated aliases: %v", err)
 	}

 	// Verify fast is GONE (not merged/preserved)
-	loaded, err = LoadIntegration("claude")
+	loaded, err = loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load after update: %v", err)
 	}
@@ -90,12 +91,12 @@ func TestSaveAliases_PreservesModels(t *testing.T) {

 	// Then update aliases
 	aliases := map[string]string{"primary": "new-model"}
-	if err := SaveAliases("claude", aliases); err != nil {
+	if err := saveAliases("claude", aliases); err != nil {
 		t.Fatalf("failed to save aliases: %v", err)
 	}

 	// Verify models are preserved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -110,16 +111,16 @@ func TestSaveAliases_EmptyMap(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save with aliases
-	if err := SaveAliases("claude", map[string]string{"primary": "model", "fast": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model", "fast": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Save empty map
-	if err := SaveAliases("claude", map[string]string{}); err != nil {
+	if err := saveAliases("claude", map[string]string{}); err != nil {
 		t.Fatalf("failed to save empty: %v", err)
 	}

-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -134,16 +135,16 @@ func TestSaveAliases_NilMap(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save with aliases first
-	if err := SaveAliases("claude", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Save nil map - should clear aliases
-	if err := SaveAliases("claude", nil); err != nil {
+	if err := saveAliases("claude", nil); err != nil {
 		t.Fatalf("failed to save nil: %v", err)
 	}

-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -154,7 +155,7 @@ func TestSaveAliases_NilMap(t *testing.T) {

 // TestSaveAliases_EmptyAppName returns error
 func TestSaveAliases_EmptyAppName(t *testing.T) {
-	err := SaveAliases("", map[string]string{"primary": "model"})
+	err := saveAliases("", map[string]string{"primary": "model"})
 	if err == nil {
 		t.Error("expected error for empty app name")
 	}
@@ -164,12 +165,12 @@ func TestSaveAliases_CaseInsensitive(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	if err := SaveAliases("Claude", map[string]string{"primary": "model1"}); err != nil {
+	if err := saveAliases("Claude", map[string]string{"primary": "model1"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

 	// Load with different case
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -178,11 +179,11 @@ func TestSaveAliases_CaseInsensitive(t *testing.T) {
 	}

 	// Update with different case
-	if err := SaveAliases("CLAUDE", map[string]string{"primary": "model2"}); err != nil {
+	if err := saveAliases("CLAUDE", map[string]string{"primary": "model2"}); err != nil {
 		t.Fatalf("failed to update: %v", err)
 	}

-	loaded, err = LoadIntegration("claude")
+	loaded, err = loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load after update: %v", err)
 	}
@@ -197,11 +198,11 @@ func TestSaveAliases_CreatesIntegration(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// Save aliases for non-existent integration
-	if err := SaveAliases("newintegration", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("newintegration", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

-	loaded, err := LoadIntegration("newintegration")
+	loaded, err := loadIntegration("newintegration")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -370,12 +371,12 @@ func TestAtomicUpdate_ServerSucceedsConfigSaved(t *testing.T) {
 		t.Fatal("server should succeed")
 	}

-	if err := SaveAliases("claude", map[string]string{"primary": "model"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model"}); err != nil {
 		t.Fatalf("saveAliases failed: %v", err)
 	}

 	// Verify it was actually saved
-	loaded, err := LoadIntegration("claude")
+	loaded, err := loadIntegration("claude")
 	if err != nil {
 		t.Fatalf("failed to load: %v", err)
 	}
@@ -407,7 +408,7 @@ func TestConfigFile_PreservesUnknownFields(t *testing.T) {
 	os.WriteFile(configPath, []byte(initialConfig), 0o644)

 	// Update aliases
-	if err := SaveAliases("claude", map[string]string{"primary": "model2"}); err != nil {
+	if err := saveAliases("claude", map[string]string{"primary": "model2"}); err != nil {
 		t.Fatalf("failed to save: %v", err)
 	}

@@ -439,6 +440,11 @@ func containsHelper(s, substr string) bool {
 	return false
 }

+func TestClaudeImplementsAliasConfigurer(t *testing.T) {
+	c := &Claude{}
+	var _ AliasConfigurer = c // Compile-time check
+}
+
 func TestModelNameEdgeCases(t *testing.T) {
 	testCases := []struct {
 		name  string
@@ -458,11 +464,11 @@ func TestModelNameEdgeCases(t *testing.T) {
 			setTestHome(t, tmpDir)

 			aliases := map[string]string{"primary": tc.model}
-			if err := SaveAliases("claude", aliases); err != nil {
+			if err := saveAliases("claude", aliases); err != nil {
 				t.Fatalf("failed to save model %q: %v", tc.model, err)
 			}

-			loaded, err := LoadIntegration("claude")
+			loaded, err := loadIntegration("claude")
 			if err != nil {
 				t.Fatalf("failed to load: %v", err)
 			}
@@ -479,7 +485,7 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial cloud config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model",
 			"fast":    "cloud-model",
 		}); err != nil {
@@ -487,13 +493,13 @@ func TestSwitchingScenarios(t *testing.T) {
 		}

 		// Switch to local (no fast)
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "local-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["fast"] != "" {
 			t.Errorf("fast should be removed, got %q", loaded.Aliases["fast"])
 		}
@@ -507,21 +513,21 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial local config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "local-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

 		// Switch to cloud (with fast)
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model",
 			"fast":    "cloud-model",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["fast"] != "cloud-model" {
 			t.Errorf("fast should be cloud-model, got %q", loaded.Aliases["fast"])
 		}
@@ -532,7 +538,7 @@ func TestSwitchingScenarios(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial cloud config
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model-1",
 			"fast":    "cloud-model-1",
 		}); err != nil {
@@ -540,14 +546,14 @@ func TestSwitchingScenarios(t *testing.T) {
 		}

 		// Switch to different cloud
-		if err := SaveAliases("claude", map[string]string{
+		if err := saveAliases("claude", map[string]string{
 			"primary": "cloud-model-2",
 			"fast":    "cloud-model-2",
 		}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["primary"] != "cloud-model-2" {
 			t.Errorf("primary should be cloud-model-2, got %q", loaded.Aliases["primary"])
 		}
@@ -557,13 +563,43 @@ func TestSwitchingScenarios(t *testing.T) {
 	})
 }

+func TestToolCapabilityFiltering(t *testing.T) {
+	t.Run("all models checked for tool capability", func(t *testing.T) {
+		// Both cloud and local models are checked for tool capability via Show API
+		// Only models with "tools" in capabilities are included
+		m := modelInfo{Name: "tool-model", Remote: false, ToolCapable: true}
+		if !m.ToolCapable {
+			t.Error("tool capable model should be marked as such")
+		}
+	})
+
+	t.Run("modelInfo includes ToolCapable field", func(t *testing.T) {
+		m := modelInfo{Name: "test", Remote: true, ToolCapable: true}
+		if !m.ToolCapable {
+			t.Error("ToolCapable field should be accessible")
+		}
+	})
+}
+
+func TestIsCloudModel_RequiresClient(t *testing.T) {
+	t.Run("nil client always returns false", func(t *testing.T) {
+		// isCloudModel now only uses Show API, no suffix detection
+		if isCloudModel(context.Background(), nil, "model:cloud") {
+			t.Error("nil client should return false regardless of suffix")
+		}
+		if isCloudModel(context.Background(), nil, "local-model") {
+			t.Error("nil client should return false")
+		}
+	})
+}
+
 func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 	t.Run("saveAliases followed by saveIntegration keeps them in sync", func(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)

 		// Save aliases with one model
-		if err := SaveAliases("claude", map[string]string{"primary": "model-a"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "model-a"}); err != nil {
 			t.Fatal(err)
 		}

@@ -572,7 +608,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Aliases["primary"] != loaded.Models[0] {
 			t.Errorf("aliases.primary (%q) != models[0] (%q)", loaded.Aliases["primary"], loaded.Models[0])
 		}
@@ -586,11 +622,11 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		if err := SaveIntegration("claude", []string{"old-model"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "new-model"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "new-model"}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")

 		// They should be different (this is the bug state)
 		if loaded.Models[0] == loaded.Aliases["primary"] {
@@ -602,7 +638,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 			t.Fatal(err)
 		}

-		loaded, _ = LoadIntegration("claude")
+		loaded, _ = loadIntegration("claude")
 		if loaded.Models[0] != loaded.Aliases["primary"] {
 			t.Errorf("after fix: models[0] (%q) should equal aliases.primary (%q)",
 				loaded.Models[0], loaded.Aliases["primary"])
@@ -617,20 +653,20 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		if err := SaveIntegration("claude", []string{"initial-model"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "initial-model"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "initial-model"}); err != nil {
 			t.Fatal(err)
 		}

 		// Update aliases AND models together
 		newAliases := map[string]string{"primary": "updated-model"}
-		if err := SaveAliases("claude", newAliases); err != nil {
+		if err := saveAliases("claude", newAliases); err != nil {
 			t.Fatal(err)
 		}
 		if err := SaveIntegration("claude", []string{newAliases["primary"]}); err != nil {
 			t.Fatal(err)
 		}

-		loaded, _ := LoadIntegration("claude")
+		loaded, _ := loadIntegration("claude")
 		if loaded.Models[0] != "updated-model" {
 			t.Errorf("models[0] should be updated-model, got %q", loaded.Models[0])
 		}
@@ -10,10 +10,17 @@ import (
 // setTestHome sets both HOME (Unix) and USERPROFILE (Windows) for cross-platform tests
 func setTestHome(t *testing.T, dir string) {
 	t.Setenv("HOME", dir)
-	t.Setenv("TMPDIR", dir)
 	t.Setenv("USERPROFILE", dir)
 }

+// editorPaths is a test helper that safely calls Paths if the runner implements Editor
+func editorPaths(r Runner) []string {
+	if editor, ok := r.(Editor); ok {
+		return editor.Paths()
+	}
+	return nil
+}
+
 func TestIntegrationConfig(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
@@ -24,7 +31,7 @@ func TestIntegrationConfig(t *testing.T) {
 			t.Fatal(err)
 		}

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -48,11 +55,11 @@ func TestIntegrationConfig(t *testing.T) {
 			"primary": "llama3.2:70b",
 			"fast":    "llama3.2:8b",
 		}
-		if err := SaveAliases("claude", aliases); err != nil {
+		if err := saveAliases("claude", aliases); err != nil {
 			t.Fatal(err)
 		}

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -70,14 +77,14 @@ func TestIntegrationConfig(t *testing.T) {
 		if err := SaveIntegration("claude", []string{"model-a"}); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveAliases("claude", map[string]string{"primary": "model-a", "fast": "model-small"}); err != nil {
+		if err := saveAliases("claude", map[string]string{"primary": "model-a", "fast": "model-small"}); err != nil {
 			t.Fatal(err)
 		}

 		if err := SaveIntegration("claude", []string{"model-b"}); err != nil {
 			t.Fatal(err)
 		}
-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -89,7 +96,7 @@ func TestIntegrationConfig(t *testing.T) {
 	t.Run("defaultModel returns first model", func(t *testing.T) {
 		SaveIntegration("codex", []string{"model-a", "model-b"})

-		config, _ := LoadIntegration("codex")
+		config, _ := loadIntegration("codex")
 		defaultModel := ""
 		if len(config.Models) > 0 {
 			defaultModel = config.Models[0]
@@ -113,7 +120,7 @@ func TestIntegrationConfig(t *testing.T) {
 	t.Run("app name is case-insensitive", func(t *testing.T) {
 		SaveIntegration("Claude", []string{"model-x"})

-		config, err := LoadIntegration("claude")
+		config, err := loadIntegration("claude")
 		if err != nil {
 			t.Fatal(err)
 		}
@@ -130,8 +137,8 @@ func TestIntegrationConfig(t *testing.T) {
 		SaveIntegration("app1", []string{"model-1"})
 		SaveIntegration("app2", []string{"model-2"})

-		config1, _ := LoadIntegration("app1")
-		config2, _ := LoadIntegration("app2")
+		config1, _ := loadIntegration("app1")
+		config2, _ := loadIntegration("app2")

 		defaultModel1 := ""
 		if len(config1.Models) > 0 {
@@ -178,6 +185,64 @@ func TestListIntegrations(t *testing.T) {
 	})
 }

+func TestEditorPaths(t *testing.T) {
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	t.Run("returns empty for claude (no Editor)", func(t *testing.T) {
+		r := integrations["claude"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths for claude, got %v", paths)
+		}
+	})
+
+	t.Run("returns empty for codex (no Editor)", func(t *testing.T) {
+		r := integrations["codex"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths for codex, got %v", paths)
+		}
+	})
+
+	t.Run("returns empty for droid when no config exists", func(t *testing.T) {
+		r := integrations["droid"]
+		paths := editorPaths(r)
+		if len(paths) != 0 {
+			t.Errorf("expected no paths, got %v", paths)
+		}
+	})
+
+	t.Run("returns path for droid when config exists", func(t *testing.T) {
+		settingsDir, _ := os.UserHomeDir()
+		settingsDir = filepath.Join(settingsDir, ".factory")
+		os.MkdirAll(settingsDir, 0o755)
+		os.WriteFile(filepath.Join(settingsDir, "settings.json"), []byte(`{}`), 0o644)
+
+		r := integrations["droid"]
+		paths := editorPaths(r)
+		if len(paths) != 1 {
+			t.Errorf("expected 1 path, got %d", len(paths))
+		}
+	})
+
+	t.Run("returns paths for opencode when configs exist", func(t *testing.T) {
+		home, _ := os.UserHomeDir()
+		configDir := filepath.Join(home, ".config", "opencode")
+		stateDir := filepath.Join(home, ".local", "state", "opencode")
+		os.MkdirAll(configDir, 0o755)
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(filepath.Join(configDir, "opencode.json"), []byte(`{}`), 0o644)
+		os.WriteFile(filepath.Join(stateDir, "model.json"), []byte(`{}`), 0o644)
+
+		r := integrations["opencode"]
+		paths := editorPaths(r)
+		if len(paths) != 2 {
+			t.Errorf("expected 2 paths, got %d: %v", len(paths), paths)
+		}
+	})
+}
+
 func TestLoadIntegration_CorruptedJSON(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)
@@ -186,7 +251,7 @@ func TestLoadIntegration_CorruptedJSON(t *testing.T) {
 	os.MkdirAll(dir, 0o755)
 	os.WriteFile(filepath.Join(dir, "config.json"), []byte(`{corrupted json`), 0o644)

-	_, err := LoadIntegration("test")
+	_, err := loadIntegration("test")
 	if err == nil {
 		t.Error("expected error for nonexistent integration in corrupted file")
 	}
@@ -200,7 +265,7 @@ func TestSaveIntegration_NilModels(t *testing.T) {
 		t.Fatalf("saveIntegration with nil models failed: %v", err)
 	}

-	config, err := LoadIntegration("test")
+	config, err := loadIntegration("test")
 	if err != nil {
 		t.Fatalf("loadIntegration failed: %v", err)
 	}
@@ -229,7 +294,7 @@ func TestLoadIntegration_NonexistentIntegration(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	_, err := LoadIntegration("nonexistent")
+	_, err := loadIntegration("nonexistent")
 	if err == nil {
 		t.Error("expected error for nonexistent integration, got nil")
 	}
@@ -1,14 +1,16 @@
-package launch
+package config

 import (
+	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"slices"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/envconfig"
 )

@@ -40,11 +42,30 @@ type modelEntry struct {

 func (d *Droid) String() string { return "Droid" }

-func (d *Droid) Run(model string, _ []LaunchModel, args []string) error {
+func (d *Droid) Run(model string, args []string) error {
 	if _, err := exec.LookPath("droid"); err != nil {
 		return fmt.Errorf("droid is not installed, install from https://docs.factory.ai/cli/getting-started/quickstart")
 	}

+	// Call Edit() to ensure config is up-to-date before launch
+	models := []string{model}
+	if config, err := loadIntegration("droid"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	var err error
+	models, err = resolveEditorModels("droid", models, func() ([]string, error) {
+		return selectModels(context.Background(), "droid", "")
+	})
+	if errors.Is(err, errCancelled) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	if err := d.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
 	cmd := exec.Command("droid", args...)
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
@@ -64,7 +85,7 @@ func (d *Droid) Paths() []string {
 	return nil
 }

-func (d *Droid) Edit(models []LaunchModel) error {
+func (d *Droid) Edit(models []string) error {
 	if len(models) == 0 {
 		return nil
 	}
@@ -90,16 +111,6 @@ func (d *Droid) Edit(models []LaunchModel) error {
 		json.Unmarshal(data, &settings) // ignore error, zero values are fine
 	}

-	settingsMap = updateDroidSettings(settingsMap, settings, models)
-
-	data, err := json.MarshalIndent(settingsMap, "", "  ")
-	if err != nil {
-		return err
-	}
-	return fileutil.WriteWithBackup(settingsPath, data, "droid")
-}
-
-func updateDroidSettings(settingsMap map[string]any, settings droidSettings, models []LaunchModel) map[string]any {
 	// Keep only non-Ollama models from the raw map (preserves extra fields)
 	// Rebuild Ollama models
 	var nonOllamaModels []any
@@ -114,23 +125,26 @@ func updateDroidSettings(settingsMap map[string]any, settings droidSettings, mod
 	}

 	// Build new Ollama model entries with sequential indices (0, 1, 2, ...)
+	client, _ := api.ClientFromEnvironment()

 	var newModels []any
 	var defaultModelID string
 	for i, model := range models {
 		maxOutput := 64000
-		if model.MaxOutputTokens > 0 {
-			maxOutput = model.MaxOutputTokens
+		if isCloudModel(context.Background(), client, model) {
+			if l, ok := lookupCloudModelLimit(model); ok {
+				maxOutput = l.Output
+			}
 		}
-		modelID := fmt.Sprintf("custom:%s-%d", model.Name, i)
+		modelID := fmt.Sprintf("custom:%s-%d", model, i)
 		newModels = append(newModels, modelEntry{
-			Model:           model.Name,
-			DisplayName:     model.Name,
+			Model:           model,
+			DisplayName:     model,
 			BaseURL:         envconfig.Host().String() + "/v1",
 			APIKey:          "ollama",
 			Provider:        "generic-chat-completion-api",
 			MaxOutputTokens: maxOutput,
-			SupportsImages:  model.HasCapability("vision"),
+			SupportsImages:  false,
 			ID:              modelID,
 			Index:           i,
 		})
@@ -153,7 +167,12 @@ func updateDroidSettings(settingsMap map[string]any, settings droidSettings, mod
 	}

 	settingsMap["sessionDefaultSettings"] = sessionSettings
-	return settingsMap
+
+	data, err := json.MarshalIndent(settingsMap, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(settingsPath, data)
 }

 func (d *Droid) Models() []string {
@@ -1,4 +1,4 @@
-package launch
+package config

 import (
 	"encoding/json"
@@ -6,8 +6,6 @@ import (
 	"os"
 	"path/filepath"
 	"testing"
-
-	"github.com/ollama/ollama/cmd/internal/fileutil"
 )

 func TestDroidIntegration(t *testing.T) {
@@ -63,7 +61,7 @@ func TestDroidEdit(t *testing.T) {

 	t.Run("fresh install creates models with sequential indices", func(t *testing.T) {
 		cleanup()
-		if err := d.Edit(testLaunchModels("model-a", "model-b")); err != nil {
+		if err := d.Edit([]string{"model-a", "model-b"}); err != nil {
 			t.Fatal(err)
 		}

@@ -99,7 +97,7 @@ func TestDroidEdit(t *testing.T) {

 	t.Run("sets sessionDefaultSettings.model to first model ID", func(t *testing.T) {
 		cleanup()
-		if err := d.Edit(testLaunchModels("model-a", "model-b")); err != nil {
+		if err := d.Edit([]string{"model-a", "model-b"}); err != nil {
 			t.Fatal(err)
 		}

@@ -116,10 +114,10 @@ func TestDroidEdit(t *testing.T) {
 	t.Run("re-indexes when models removed", func(t *testing.T) {
 		cleanup()
 		// Add three models
-		d.Edit(testLaunchModels("model-a", "model-b", "model-c"))
+		d.Edit([]string{"model-a", "model-b", "model-c"})

 		// Remove middle model
-		d.Edit(testLaunchModels("model-a", "model-c"))
+		d.Edit([]string{"model-a", "model-c"})

 		settings := readSettings()
 		models := getCustomModels(settings)
@@ -155,7 +153,7 @@ func TestDroidEdit(t *testing.T) {
 			]
 		}`), 0o644)

-		d.Edit(testLaunchModels("model-a"))
+		d.Edit([]string{"model-a"})

 		settings := readSettings()
 		models := getCustomModels(settings)
@@ -184,7 +182,7 @@ func TestDroidEdit(t *testing.T) {
 			"sessionDefaultSettings": {"autonomyMode": "auto-high"}
 		}`), 0o644)

-		d.Edit(testLaunchModels("model-a"))
+		d.Edit([]string{"model-a"})

 		settings := readSettings()

@@ -203,7 +201,7 @@ func TestDroidEdit(t *testing.T) {

 	t.Run("required fields present", func(t *testing.T) {
 		cleanup()
-		d.Edit(testLaunchModels("test-model"))
+		d.Edit([]string{"test-model"})

 		settings := readSettings()
 		models := getCustomModels(settings)
@@ -239,7 +237,7 @@ func TestDroidEdit(t *testing.T) {
 			"sessionDefaultSettings": {"reasoningEffort": "off"}
 		}`), 0o644)

-		d.Edit(testLaunchModels("model-a"))
+		d.Edit([]string{"model-a"})

 		settings := readSettings()
 		session := settings["sessionDefaultSettings"].(map[string]any)
@@ -256,7 +254,7 @@ func TestDroidEdit(t *testing.T) {
 			"sessionDefaultSettings": {"reasoningEffort": "high"}
 		}`), 0o644)

-		d.Edit(testLaunchModels("model-a"))
+		d.Edit([]string{"model-a"})

 		settings := readSettings()
 		session := settings["sessionDefaultSettings"].(map[string]any)
@@ -281,7 +279,7 @@ func TestDroidEdit_CorruptedJSON(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(`{corrupted json content`), 0o644)

 	// Corrupted JSON should return an error so user knows something is wrong
-	err := d.Edit(testLaunchModels("model-a"))
+	err := d.Edit([]string{"model-a"})
 	if err == nil {
 		t.Fatal("expected error for corrupted JSON, got nil")
 	}
@@ -306,7 +304,7 @@ func TestDroidEdit_WrongTypeCustomModels(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(`{"customModels": "not an array"}`), 0o644)

 	// Should not panic - wrong type should be handled gracefully
-	err := d.Edit(testLaunchModels("model-a"))
+	err := d.Edit([]string{"model-a"})
 	if err != nil {
 		t.Fatalf("Edit failed with wrong type customModels: %v", err)
 	}
@@ -338,7 +336,7 @@ func TestDroidEdit_EmptyModels(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(originalContent), 0o644)

 	// Empty models should be no-op
-	err := d.Edit(testLaunchModels())
+	err := d.Edit([]string{})
 	if err != nil {
 		t.Fatalf("Edit with empty models failed: %v", err)
 	}
@@ -359,12 +357,12 @@ func TestDroidEdit_DuplicateModels(t *testing.T) {
 	settingsPath := filepath.Join(settingsDir, "settings.json")

 	// Add same model twice
-	err := d.Edit(testLaunchModels("model-a", "model-a"))
+	err := d.Edit([]string{"model-a", "model-a"})
 	if err != nil {
 		t.Fatalf("Edit with duplicates failed: %v", err)
 	}

-	settings, err := fileutil.ReadJSON(settingsPath)
+	settings, err := readJSONFile(settingsPath)
 	if err != nil {
 		t.Fatalf("readJSONFile failed: %v", err)
 	}
@@ -388,13 +386,13 @@ func TestDroidEdit_MalformedModelEntry(t *testing.T) {
 	// Model entry is a string instead of a map
 	os.WriteFile(settingsPath, []byte(`{"customModels": ["not a map", 123]}`), 0o644)

-	err := d.Edit(testLaunchModels("model-a"))
+	err := d.Edit([]string{"model-a"})
 	if err != nil {
 		t.Fatalf("Edit with malformed entries failed: %v", err)
 	}

 	// Malformed entries (non-object) are dropped - only valid model objects are preserved
-	settings, _ := fileutil.ReadJSON(settingsPath)
+	settings, _ := readJSONFile(settingsPath)
 	customModels, _ := settings["customModels"].([]any)

 	// Should have: 1 new Ollama model only (malformed entries dropped)
@@ -415,13 +413,13 @@ func TestDroidEdit_WrongTypeSessionSettings(t *testing.T) {
 	// sessionDefaultSettings is a string instead of map
 	os.WriteFile(settingsPath, []byte(`{"sessionDefaultSettings": "not a map"}`), 0o644)

-	err := d.Edit(testLaunchModels("model-a"))
+	err := d.Edit([]string{"model-a"})
 	if err != nil {
 		t.Fatalf("Edit with wrong type sessionDefaultSettings failed: %v", err)
 	}

 	// Should create proper sessionDefaultSettings
-	settings, _ := fileutil.ReadJSON(settingsPath)
+	settings, _ := readJSONFile(settingsPath)
 	session, ok := settings["sessionDefaultSettings"].(map[string]any)
 	if !ok {
 		t.Fatalf("sessionDefaultSettings should be map after setup, got %T", settings["sessionDefaultSettings"])
@@ -490,7 +488,7 @@ func TestDroidEdit_RoundTrip(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(testDroidSettingsFixture), 0o644)

 	// Edit with new models
-	if err := d.Edit(testLaunchModels("llama3", "mistral")); err != nil {
+	if err := d.Edit([]string{"llama3", "mistral"}); err != nil {
 		t.Fatal(err)
 	}

@@ -615,7 +613,7 @@ func TestDroidEdit_PreservesUnknownFields(t *testing.T) {
 		}`
 		os.WriteFile(settingsPath, []byte(original), 0o644)

-		if err := d.Edit(testLaunchModels("model-a")); err != nil {
+		if err := d.Edit([]string{"model-a"}); err != nil {
 			t.Fatal(err)
 		}

@@ -660,7 +658,7 @@ func TestDroidEdit_PreservesUnknownFields(t *testing.T) {
 		}`
 		os.WriteFile(settingsPath, []byte(original), 0o644)

-		if err := d.Edit(testLaunchModels("llama3")); err != nil {
+		if err := d.Edit([]string{"llama3"}); err != nil {
 			t.Fatal(err)
 		}

@@ -715,10 +713,10 @@ func TestDroidEdit_Idempotent(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(testDroidSettingsFixture), 0o644)

 	// Edit twice with same models
-	d.Edit(testLaunchModels("llama3", "mistral"))
+	d.Edit([]string{"llama3", "mistral"})
 	firstData, _ := os.ReadFile(settingsPath)

-	d.Edit(testLaunchModels("llama3", "mistral"))
+	d.Edit([]string{"llama3", "mistral"})
 	secondData, _ := os.ReadFile(settingsPath)

 	// Results should be identical
@@ -744,7 +742,7 @@ func TestDroidEdit_MultipleConsecutiveEdits(t *testing.T) {
 		if i%2 == 0 {
 			models = []string{"model-x", "model-y", "model-z"}
 		}
-		if err := d.Edit(launchModelsFromNames(models)); err != nil {
+		if err := d.Edit(models); err != nil {
 			t.Fatalf("edit %d failed: %v", i, err)
 		}
 	}
@@ -803,7 +801,7 @@ func TestDroidEdit_UnicodeAndSpecialCharacters(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -845,7 +843,7 @@ func TestDroidEdit_LargeNumbers(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -889,7 +887,7 @@ func TestDroidEdit_EmptyAndNullValues(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -943,7 +941,7 @@ func TestDroidEdit_DeeplyNestedStructures(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -988,7 +986,7 @@ func TestDroidEdit_ModelNamesWithSpecialCharacters(t *testing.T) {
 		"model_with_underscores",
 	}

-	if err := d.Edit(launchModelsFromNames(specialModels)); err != nil {
+	if err := d.Edit(specialModels); err != nil {
 		t.Fatal(err)
 	}

@@ -1010,34 +1008,34 @@ func TestDroidEdit_ModelNamesWithSpecialCharacters(t *testing.T) {
 }

 func TestDroidEdit_MissingCustomModelsKey(t *testing.T) {
+	d := &Droid{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	settingsDir := filepath.Join(tmpDir, ".factory")
+	settingsPath := filepath.Join(settingsDir, "settings.json")
+
+	os.MkdirAll(settingsDir, 0o755)
+
 	// No customModels key at all
 	original := `{
 		"diffMode": "github",
 		"sessionDefaultSettings": {"autonomyMode": "auto-high"}
 	}`
+	os.WriteFile(settingsPath, []byte(original), 0o644)

-	var settingsStruct droidSettings
+	if err := d.Edit([]string{"model-a"}); err != nil {
+		t.Fatal(err)
+	}
+
+	data, _ := os.ReadFile(settingsPath)
 	var settings map[string]any
-	if err := json.Unmarshal([]byte(original), &settings); err != nil {
-		t.Fatal(err)
-	}
-	if err := json.Unmarshal([]byte(original), &settingsStruct); err != nil {
-		t.Fatal(err)
-	}
-
-	settings = updateDroidSettings(settings, settingsStruct, testLaunchModels("model-a"))
+	json.Unmarshal(data, &settings)

 	// Original fields preserved
 	if settings["diffMode"] != "github" {
 		t.Error("diffMode not preserved")
 	}
-	session, ok := settings["sessionDefaultSettings"].(map[string]any)
-	if !ok {
-		t.Fatal("sessionDefaultSettings not preserved")
-	}
-	if session["autonomyMode"] != "auto-high" {
-		t.Error("sessionDefaultSettings.autonomyMode not preserved")
-	}

 	// customModels created
 	models, ok := settings["customModels"].([]any)
@@ -1062,7 +1060,7 @@ func TestDroidEdit_NullCustomModels(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -1090,7 +1088,7 @@ func TestDroidEdit_MinifiedJSON(t *testing.T) {
 	original := `{"diffMode":"github","enableHooks":true,"hooks":{"imported":["cmd1","cmd2"]},"customModels":[],"sessionDefaultSettings":{}}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -1120,7 +1118,7 @@ func TestDroidEdit_CreatesDirectoryIfMissing(t *testing.T) {
 		t.Fatal("directory should not exist before test")
 	}

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -1157,7 +1155,7 @@ func TestDroidEdit_PreservesFileAfterError(t *testing.T) {
 	os.WriteFile(settingsPath, []byte(original), 0o644)

 	// Empty models list is a no-op, should not modify file
-	d.Edit(testLaunchModels())
+	d.Edit([]string{})

 	data, _ := os.ReadFile(settingsPath)
 	if string(data) != original {
@@ -1172,7 +1170,7 @@ func TestDroidEdit_BackupCreated(t *testing.T) {

 	settingsDir := filepath.Join(tmpDir, ".factory")
 	settingsPath := filepath.Join(settingsDir, "settings.json")
-	backupDir := fileutil.BackupDir()
+	backupDir := filepath.Join(os.TempDir(), "ollama-backups")

 	os.MkdirAll(settingsDir, 0o755)

@@ -1181,12 +1179,12 @@ func TestDroidEdit_BackupCreated(t *testing.T) {
 	original := fmt.Sprintf(`{"diffMode": "%s", "customModels": [], "sessionDefaultSettings": {}}`, uniqueMarker)
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

 	// Find backup containing our unique marker
-	backups, _ := filepath.Glob(filepath.Join(backupDir, "droid", "settings.json.*"))
+	backups, _ := filepath.Glob(filepath.Join(backupDir, "settings.json.*"))
 	foundBackup := false
 	for _, backup := range backups {
 		data, err := os.ReadFile(backup)
@@ -1231,7 +1229,7 @@ func TestDroidEdit_LargeNumberOfModels(t *testing.T) {
 		models = append(models, fmt.Sprintf("model-%d", i))
 	}

-	if err := d.Edit(launchModelsFromNames(models)); err != nil {
+	if err := d.Edit(models); err != nil {
 		t.Fatal(err)
 	}

@@ -1261,7 +1259,7 @@ func TestDroidEdit_LocalModelDefaultMaxOutput(t *testing.T) {
 	settingsDir := filepath.Join(tmpDir, ".factory")
 	settingsPath := filepath.Join(settingsDir, "settings.json")

-	if err := d.Edit(testLaunchModels("llama3.2")); err != nil {
+	if err := d.Edit([]string{"llama3.2"}); err != nil {
 		t.Fatal(err)
 	}

@@ -1278,18 +1276,26 @@ func TestDroidEdit_LocalModelDefaultMaxOutput(t *testing.T) {

 func TestDroidEdit_CloudModelLimitsUsed(t *testing.T) {
 	// Verify that every cloud model in cloudModelLimits has a valid output
-	// value that would be used for maxOutputTokens when the selected model uses
-	// the explicit :cloud source tag.
+	// value that would be used for maxOutputTokens when isCloudModel returns true.
+	// :cloud suffix stripping must also work since that's how users specify them.
 	for name, expected := range cloudModelLimits {
 		t.Run(name, func(t *testing.T) {
-			cloudName := name + ":cloud"
-			l, ok := lookupCloudModelLimit(cloudName)
+			l, ok := lookupCloudModelLimit(name)
 			if !ok {
-				t.Fatalf("lookupCloudModelLimit(%q) returned false", cloudName)
+				t.Fatalf("lookupCloudModelLimit(%q) returned false", name)
 			}
 			if l.Output != expected.Output {
 				t.Errorf("output = %d, want %d", l.Output, expected.Output)
 			}
+			// Also verify :cloud suffix lookup
+			cloudName := name + ":cloud"
+			l2, ok := lookupCloudModelLimit(cloudName)
+			if !ok {
+				t.Fatalf("lookupCloudModelLimit(%q) returned false", cloudName)
+			}
+			if l2.Output != expected.Output {
+				t.Errorf(":cloud output = %d, want %d", l2.Output, expected.Output)
+			}
 		})
 	}
 }
@@ -1312,7 +1318,7 @@ func TestDroidEdit_ArraysWithMixedTypes(t *testing.T) {
 	}`
 	os.WriteFile(settingsPath, []byte(original), 0o644)

-	if err := d.Edit(testLaunchModels("model-a")); err != nil {
+	if err := d.Edit([]string{"model-a"}); err != nil {
 		t.Fatal(err)
 	}

@@ -0,0 +1,99 @@
+package config
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+func readJSONFile(path string) (map[string]any, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	var result map[string]any
+	if err := json.Unmarshal(data, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func copyFile(src, dst string) error {
+	info, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+	data, err := os.ReadFile(src)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(dst, data, info.Mode().Perm())
+}
+
+func backupDir() string {
+	return filepath.Join(os.TempDir(), "ollama-backups")
+}
+
+func backupToTmp(srcPath string) (string, error) {
+	dir := backupDir()
+	if err := os.MkdirAll(dir, 0o755); err != nil {
+		return "", err
+	}
+
+	backupPath := filepath.Join(dir, fmt.Sprintf("%s.%d", filepath.Base(srcPath), time.Now().Unix()))
+	if err := copyFile(srcPath, backupPath); err != nil {
+		return "", err
+	}
+	return backupPath, nil
+}
+
+// writeWithBackup writes data to path via temp file + rename, backing up any existing file first
+func writeWithBackup(path string, data []byte) error {
+	var backupPath string
+	// backup must be created before any writes to the target file
+	if existingContent, err := os.ReadFile(path); err == nil {
+		if !bytes.Equal(existingContent, data) {
+			backupPath, err = backupToTmp(path)
+			if err != nil {
+				return fmt.Errorf("backup failed: %w", err)
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("read existing file: %w", err)
+	}
+
+	dir := filepath.Dir(path)
+	tmp, err := os.CreateTemp(dir, ".tmp-*")
+	if err != nil {
+		return fmt.Errorf("create temp failed: %w", err)
+	}
+	tmpPath := tmp.Name()
+
+	if _, err := tmp.Write(data); err != nil {
+		_ = tmp.Close()
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("write failed: %w", err)
+	}
+	if err := tmp.Sync(); err != nil {
+		_ = tmp.Close()
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("sync failed: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		_ = os.Remove(tmpPath)
+		return fmt.Errorf("close failed: %w", err)
+	}
+
+	if err := os.Rename(tmpPath, path); err != nil {
+		_ = os.Remove(tmpPath)
+		if backupPath != "" {
+			_ = copyFile(backupPath, path)
+		}
+		return fmt.Errorf("rename failed: %w", err)
+	}
+
+	return nil
+}
@@ -1,4 +1,4 @@
-package fileutil
+package config

 import (
 	"encoding/json"
@@ -9,27 +9,6 @@ import (
 	"testing"
 )

-func TestMain(m *testing.M) {
-	tmpRoot, err := os.MkdirTemp("", "fileutil-test-*")
-	if err != nil {
-		panic(err)
-	}
-
-	if err := os.Setenv("TMPDIR", tmpRoot); err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("HOME", tmpRoot); err != nil {
-		panic(err)
-	}
-	if err := os.Setenv("USERPROFILE", tmpRoot); err != nil {
-		panic(err)
-	}
-
-	code := m.Run()
-	_ = os.RemoveAll(tmpRoot)
-	os.Exit(code)
-}
-
 func mustMarshal(t *testing.T, v any) []byte {
 	t.Helper()
 	data, err := json.MarshalIndent(v, "", "  ")
@@ -39,30 +18,14 @@ func mustMarshal(t *testing.T, v any) []byte {
 	return data
 }

-func isolatedTempDir(t *testing.T) string {
-	t.Helper()
-	return t.TempDir()
-}
-
 func TestWriteWithBackup(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
-
-	t.Run("uses ollama directory under home", func(t *testing.T) {
-		home := t.TempDir()
-		t.Setenv("HOME", home)
-		t.Setenv("USERPROFILE", home)
-
-		want := filepath.Join(home, ".ollama", "backup")
-		if got := BackupDir(); got != want {
-			t.Fatalf("BackupDir() = %q, want %q", got, want)
-		}
-	})
+	tmpDir := t.TempDir()

 	t.Run("creates file", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "new.json")
 		data := mustMarshal(t, map[string]string{"key": "value"})

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

@@ -80,17 +43,17 @@ func TestWriteWithBackup(t *testing.T) {
 		}
 	})

-	t.Run("creates backup in the shared backup directory", func(t *testing.T) {
+	t.Run("creates backup in /tmp/ollama-backups", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "backup.json")

 		os.WriteFile(path, []byte(`{"original": true}`), 0o644)

 		data := mustMarshal(t, map[string]bool{"updated": true})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, err := os.ReadDir(BackupDir())
+		entries, err := os.ReadDir(backupDir())
 		if err != nil {
 			t.Fatal("backup directory not created")
 		}
@@ -100,7 +63,7 @@ func TestWriteWithBackup(t *testing.T) {
 			if filepath.Ext(entry.Name()) != ".json" {
 				name := entry.Name()
 				if len(name) > len("backup.json.") && name[:len("backup.json.")] == "backup.json." {
-					backupPath := filepath.Join(BackupDir(), name)
+					backupPath := filepath.Join(backupDir(), name)
 					backup, err := os.ReadFile(backupPath)
 					if err == nil {
 						var backupData map[string]bool
@@ -116,7 +79,7 @@ func TestWriteWithBackup(t *testing.T) {
 		}

 		if !foundBackup {
-			t.Error("backup file not created in backup directory")
+			t.Error("backup file not created in /tmp/ollama-backups")
 		}

 		current, _ := os.ReadFile(path)
@@ -127,44 +90,15 @@ func TestWriteWithBackup(t *testing.T) {
 		}
 	})

-	t.Run("stores hinted backups under a subdirectory", func(t *testing.T) {
-		path := filepath.Join(tmpDir, "hinted.json")
-		os.WriteFile(path, []byte(`{"original": true}`), 0o644)
-
-		data := mustMarshal(t, map[string]bool{"updated": true})
-		if err := WriteWithBackup(path, data, "openclaw"); err != nil {
-			t.Fatal(err)
-		}
-
-		entries, err := os.ReadDir(filepath.Join(BackupDir(), "openclaw"))
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		var found bool
-		for _, entry := range entries {
-			name := entry.Name()
-			if len(name) > len("hinted.json.") && name[:len("hinted.json.")] == "hinted.json." {
-				found = true
-				_ = os.Remove(filepath.Join(BackupDir(), "openclaw", name))
-				break
-			}
-		}
-
-		if !found {
-			t.Error("backup file was not created under hint directory")
-		}
-	})
-
 	t.Run("no backup for new file", func(t *testing.T) {
 		path := filepath.Join(tmpDir, "nobak.json")

 		data := mustMarshal(t, map[string]string{"new": "file"})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, _ := os.ReadDir(BackupDir())
+		entries, _ := os.ReadDir(backupDir())
 		for _, entry := range entries {
 			if len(entry.Name()) > len("nobak.json.") && entry.Name()[:len("nobak.json.")] == "nobak.json." {
 				t.Error("backup should not exist for new file")
@@ -177,11 +111,11 @@ func TestWriteWithBackup(t *testing.T) {

 		data := mustMarshal(t, map[string]string{"key": "value"})

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries1, _ := os.ReadDir(BackupDir())
+		entries1, _ := os.ReadDir(backupDir())
 		countBefore := 0
 		for _, e := range entries1 {
 			if len(e.Name()) > len("unchanged.json.") && e.Name()[:len("unchanged.json.")] == "unchanged.json." {
@@ -189,11 +123,11 @@ func TestWriteWithBackup(t *testing.T) {
 			}
 		}

-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries2, _ := os.ReadDir(BackupDir())
+		entries2, _ := os.ReadDir(backupDir())
 		countAfter := 0
 		for _, e := range entries2 {
 			if len(e.Name()) > len("unchanged.json.") && e.Name()[:len("unchanged.json.")] == "unchanged.json." {
@@ -211,11 +145,11 @@ func TestWriteWithBackup(t *testing.T) {

 		os.WriteFile(path, []byte(`{"v": 1}`), 0o644)
 		data := mustMarshal(t, map[string]int{"v": 2})
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatal(err)
 		}

-		entries, _ := os.ReadDir(BackupDir())
+		entries, _ := os.ReadDir(backupDir())
 		var found bool
 		for _, entry := range entries {
 			name := entry.Name()
@@ -227,7 +161,7 @@ func TestWriteWithBackup(t *testing.T) {
 					}
 				}
 				found = true
-				os.Remove(filepath.Join(BackupDir(), name))
+				os.Remove(filepath.Join(backupDir(), name))
 				break
 			}
 		}
@@ -235,35 +169,6 @@ func TestWriteWithBackup(t *testing.T) {
 			t.Error("backup file with timestamp not found")
 		}
 	})
-
-	t.Run("retains only the five newest backups per file", func(t *testing.T) {
-		path := filepath.Join(tmpDir, "pruned.json")
-		if err := os.WriteFile(path, []byte(`{"v": 0}`), 0o644); err != nil {
-			t.Fatal(err)
-		}
-
-		for i := 1; i <= maxBackupsPerFile; i++ {
-			backupPath := filepath.Join(BackupDir(), fmt.Sprintf("pruned.json.%d", i))
-			if err := os.WriteFile(backupPath, []byte(fmt.Sprintf(`{"v": %d}`, i)), 0o644); err != nil {
-				t.Fatal(err)
-			}
-		}
-
-		if err := WriteWithBackup(path, []byte(`{"v": 1}`)); err != nil {
-			t.Fatal(err)
-		}
-
-		backups, err := filepath.Glob(filepath.Join(BackupDir(), "pruned.json.*"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if len(backups) != maxBackupsPerFile {
-			t.Fatalf("expected %d backups after pruning, got %d", maxBackupsPerFile, len(backups))
-		}
-		if _, err := os.Stat(filepath.Join(BackupDir(), "pruned.json.1")); !os.IsNotExist(err) {
-			t.Fatalf("expected oldest backup to be pruned, stat err = %v", err)
-		}
-	})
 }

 // Edge case tests for files.go
@@ -275,7 +180,7 @@ func TestWriteWithBackup_FailsIfBackupFails(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "config.json")

 	// Create original file
@@ -283,13 +188,13 @@ func TestWriteWithBackup_FailsIfBackupFails(t *testing.T) {
 	os.WriteFile(path, originalContent, 0o644)

 	// Make backup directory read-only to force backup failure
-	backupDir := BackupDir()
+	backupDir := backupDir()
 	os.MkdirAll(backupDir, 0o755)
 	os.Chmod(backupDir, 0o444) // Read-only
 	defer os.Chmod(backupDir, 0o755)

 	newContent := []byte(`{"updated": true}`)
-	err := WriteWithBackup(path, newContent)
+	err := writeWithBackup(path, newContent)

 	// Should fail because backup couldn't be created
 	if err == nil {
@@ -310,7 +215,7 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// Create a read-only directory
 	readOnlyDir := filepath.Join(tmpDir, "readonly")
@@ -319,50 +224,20 @@ func TestWriteWithBackup_PermissionDenied(t *testing.T) {
 	defer os.Chmod(readOnlyDir, 0o755)

 	path := filepath.Join(readOnlyDir, "config.json")
-	err := WriteWithBackup(path, []byte(`{"test": true}`))
+	err := writeWithBackup(path, []byte(`{"test": true}`))

 	if err == nil {
 		t.Error("expected permission error, got nil")
 	}
 }

-func TestWriteWithBackup_UnchangedContentIsNoOp(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("permission tests unreliable on Windows")
-	}
-
-	tmpDir := isolatedTempDir(t)
-	path := filepath.Join(tmpDir, "unchanged-noop.json")
-	data := []byte(`{"same":true}`)
-	if err := os.WriteFile(path, data, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := os.Chmod(tmpDir, 0o555); err != nil {
-		t.Fatal(err)
-	}
-	defer os.Chmod(tmpDir, 0o755)
-
-	if err := WriteWithBackup(path, data); err != nil {
-		t.Fatalf("expected unchanged write to be a no-op, got %v", err)
-	}
-
-	backups, err := filepath.Glob(filepath.Join(BackupDir(), "unchanged-noop.json.*"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(backups) != 0 {
-		t.Fatalf("expected no backups for unchanged content, got %d", len(backups))
-	}
-}
-
 // TestWriteWithBackup_DirectoryDoesNotExist verifies behavior when target directory doesn't exist.
 // writeWithBackup doesn't create directories - caller is responsible.
 func TestWriteWithBackup_DirectoryDoesNotExist(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "nonexistent", "subdir", "config.json")

-	err := WriteWithBackup(path, []byte(`{"test": true}`))
+	err := writeWithBackup(path, []byte(`{"test": true}`))

 	// Should fail because directory doesn't exist
 	if err == nil {
@@ -377,7 +252,7 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 		t.Skip("symlink tests may require admin on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	realFile := filepath.Join(tmpDir, "real.json")
 	symlink := filepath.Join(tmpDir, "link.json")

@@ -386,7 +261,7 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 	os.Symlink(realFile, symlink)

 	// Write through symlink
-	err := WriteWithBackup(symlink, []byte(`{"v": 2}`))
+	err := writeWithBackup(symlink, []byte(`{"v": 2}`))
 	if err != nil {
 		t.Fatalf("writeWithBackup through symlink failed: %v", err)
 	}
@@ -401,15 +276,15 @@ func TestWriteWithBackup_SymlinkTarget(t *testing.T) {
 // TestBackupToTmp_SpecialCharsInFilename verifies backup works with special characters.
 // User may have config files with unusual names.
 func TestBackupToTmp_SpecialCharsInFilename(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// File with spaces and special chars
 	path := filepath.Join(tmpDir, "my config (backup).json")
 	os.WriteFile(path, []byte(`{"test": true}`), 0o644)

-	backupPath, err := writeBackupCopy(path, "")
+	backupPath, err := backupToTmp(path)
 	if err != nil {
-		t.Fatalf("writeBackupCopy with special chars failed: %v", err)
+		t.Fatalf("backupToTmp with special chars failed: %v", err)
 	}

 	// Verify backup exists and has correct content
@@ -430,7 +305,7 @@ func TestCopyFile_PreservesPermissions(t *testing.T) {
 		t.Skip("permission preservation tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	src := filepath.Join(tmpDir, "src.json")
 	dst := filepath.Join(tmpDir, "dst.json")

@@ -452,7 +327,7 @@ func TestCopyFile_PreservesPermissions(t *testing.T) {

 // TestCopyFile_SourceNotFound verifies clear error when source doesn't exist.
 func TestCopyFile_SourceNotFound(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	src := filepath.Join(tmpDir, "nonexistent.json")
 	dst := filepath.Join(tmpDir, "dst.json")

@@ -464,11 +339,11 @@ func TestCopyFile_SourceNotFound(t *testing.T) {

 // TestWriteWithBackup_TargetIsDirectory verifies error when path points to a directory.
 func TestWriteWithBackup_TargetIsDirectory(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	dirPath := filepath.Join(tmpDir, "actualdir")
 	os.MkdirAll(dirPath, 0o755)

-	err := WriteWithBackup(dirPath, []byte(`{"test": true}`))
+	err := writeWithBackup(dirPath, []byte(`{"test": true}`))
 	if err == nil {
 		t.Error("expected error when target is a directory, got nil")
 	}
@@ -476,10 +351,10 @@ func TestWriteWithBackup_TargetIsDirectory(t *testing.T) {

 // TestWriteWithBackup_EmptyData verifies writing zero bytes works correctly.
 func TestWriteWithBackup_EmptyData(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "empty.json")

-	err := WriteWithBackup(path, []byte{})
+	err := writeWithBackup(path, []byte{})
 	if err != nil {
 		t.Fatalf("writeWithBackup with empty data failed: %v", err)
 	}
@@ -500,7 +375,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "unreadable.json")

 	// Create file and make it unreadable
@@ -509,7 +384,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 	defer os.Chmod(path, 0o644)

 	// Should fail because we can't read the file to compare/backup
-	err := WriteWithBackup(path, []byte(`{"updated": true}`))
+	err := writeWithBackup(path, []byte(`{"updated": true}`))
 	if err == nil {
 		t.Error("expected error when file is unreadable, got nil")
 	}
@@ -518,7 +393,7 @@ func TestWriteWithBackup_FileUnreadableButDirWritable(t *testing.T) {
 // TestWriteWithBackup_RapidSuccessiveWrites verifies backup works with multiple writes
 // within the same second (timestamp collision scenario).
 func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "rapid.json")

 	// Create initial file
@@ -527,7 +402,7 @@ func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
 	// Rapid successive writes
 	for i := 1; i <= 3; i++ {
 		data := []byte(fmt.Sprintf(`{"v": %d}`, i))
-		if err := WriteWithBackup(path, data); err != nil {
+		if err := writeWithBackup(path, data); err != nil {
 			t.Fatalf("write %d failed: %v", i, err)
 		}
 	}
@@ -539,7 +414,7 @@ func TestWriteWithBackup_RapidSuccessiveWrites(t *testing.T) {
 	}

 	// Verify at least one backup exists
-	entries, _ := os.ReadDir(BackupDir())
+	entries, _ := os.ReadDir(backupDir())
 	var backupCount int
 	for _, e := range entries {
 		if len(e.Name()) > len("rapid.json.") && e.Name()[:len("rapid.json.")] == "rapid.json." {
@@ -557,9 +432,8 @@ func TestWriteWithBackup_BackupDirIsFile(t *testing.T) {
 		t.Skip("test modifies system temp directory")
 	}

-	tmpDir := isolatedTempDir(t)
 	// Create a file at the backup directory path
-	backupPath := BackupDir()
+	backupPath := backupDir()
 	// Clean up any existing directory first
 	os.RemoveAll(backupPath)
 	// Create a file instead of directory
@@ -569,10 +443,11 @@ func TestWriteWithBackup_BackupDirIsFile(t *testing.T) {
 		os.MkdirAll(backupPath, 0o755)
 	}()

+	tmpDir := t.TempDir()
 	path := filepath.Join(tmpDir, "test.json")
 	os.WriteFile(path, []byte(`{"original": true}`), 0o644)

-	err := WriteWithBackup(path, []byte(`{"updated": true}`))
+	err := writeWithBackup(path, []byte(`{"updated": true}`))
 	if err == nil {
 		t.Error("expected error when backup dir is a file, got nil")
 	}
@@ -584,7 +459,7 @@ func TestWriteWithBackup_NoOrphanTempFiles(t *testing.T) {
 		t.Skip("permission tests unreliable on Windows")
 	}

-	tmpDir := isolatedTempDir(t)
+	tmpDir := t.TempDir()

 	// Count existing temp files
 	countTempFiles := func() int {
@@ -618,7 +493,7 @@ func TestWriteWithBackup_NoOrphanTempFiles(t *testing.T) {
 	badPath := filepath.Join(tmpDir, "isdir")
 	os.MkdirAll(badPath, 0o755)

-	_ = WriteWithBackup(badPath, []byte(`{"test": true}`))
+	_ = writeWithBackup(badPath, []byte(`{"test": true}`))

 	after := countTempFiles()
 	if after > before {
@@ -1,6 +1,7 @@
-package launch
+package config

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net"
@@ -9,31 +10,34 @@ import (
 	"os/exec"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"strings"
 	"time"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/envconfig"
+	"github.com/ollama/ollama/types/model"
 )

 const defaultGatewayPort = 18789

-// openclawFreshInstall is set to true when ensureOpenclawInstalled performs an install
-var openclawFreshInstall bool
-
-var openclawCanInstallDaemon = canInstallDaemon
+// Bound model capability probing so launch/config cannot hang on slow/unreachable API calls.
+var openclawModelShowTimeout = 5 * time.Second

 type Openclaw struct{}

 func (c *Openclaw) String() string { return "OpenClaw" }

-func (c *Openclaw) Run(model string, _ []LaunchModel, args []string) error {
+func (c *Openclaw) Run(model string, args []string) error {
 	bin, err := ensureOpenclawInstalled()
 	if err != nil {
 		return err
 	}

-	firstLaunch := !c.onboarded()
+	firstLaunch := true
+	if integrationConfig, err := loadIntegration("openclaw"); err == nil {
+		firstLaunch = !integrationConfig.Onboarded
+	}

 	if firstLaunch {
 		fmt.Fprintf(os.Stderr, "\n%sSecurity%s\n\n", ansiBold, ansiReset)
@@ -41,46 +45,28 @@ func (c *Openclaw) Run(model string, _ []LaunchModel, args []string) error {
 		fmt.Fprintf(os.Stderr, "  A bad prompt can trick it into doing unsafe things.\n\n")
 		fmt.Fprintf(os.Stderr, "%s  Learn more: https://docs.openclaw.ai/gateway/security%s\n\n", ansiGray, ansiReset)

-		ok, err := ConfirmPrompt("I understand the risks. Continue?")
+		ok, err := confirmPrompt("I understand the risks. Continue?")
 		if err != nil {
 			return err
 		}
 		if !ok {
 			return nil
 		}
+	}

-		// Ensure the latest version is installed before onboarding so we get
-		// the newest wizard flags (e.g. --auth-choice ollama).
-		if !openclawFreshInstall {
-			update := exec.Command(bin, "update")
-			update.Env = openclawInstallEnv()
-			update.Stdout = os.Stdout
-			update.Stderr = os.Stderr
-			_ = update.Run() // best-effort; continue even if update fails
-		}
-
+	if !c.onboarded() {
 		fmt.Fprintf(os.Stderr, "\n%sSetting up OpenClaw with Ollama...%s\n", ansiGreen, ansiReset)
 		fmt.Fprintf(os.Stderr, "%s  Model: %s%s\n\n", ansiGray, model, ansiReset)

-		onboardArgs := []string{
-			"onboard",
+		cmd := exec.Command(bin, "onboard",
 			"--non-interactive",
 			"--accept-risk",
-			"--auth-choice", "ollama",
-			"--custom-base-url", envconfig.Host().String(),
-			"--custom-model-id", model,
-			// Launch owns the first real gateway startup immediately after onboarding,
-			// so don't let OpenClaw fail the whole first-run flow on a transient
-			// daemon health probe.
-			"--skip-health",
+			"--auth-choice", "skip",
+			"--gateway-token", "ollama",
+			"--install-daemon",
 			"--skip-channels",
 			"--skip-skills",
-		}
-		if openclawCanInstallDaemon() {
-			onboardArgs = append(onboardArgs, "--install-daemon")
-		}
-		cmd := exec.Command(bin, onboardArgs...)
-		cmd.Env = openclawInstallEnv()
+		)
 		cmd.Stdin = os.Stdin
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
@@ -89,25 +75,29 @@ func (c *Openclaw) Run(model string, _ []LaunchModel, args []string) error {
 		}

 		patchDeviceScopes()
+
+		// Onboarding overwrites openclaw.json, so re-apply the model config
+		// that Edit() wrote before Run() was called.
+		if err := c.Edit([]string{model}); err != nil {
+			fmt.Fprintf(os.Stderr, "%s  Warning: could not re-apply model config: %v%s\n", ansiYellow, err, ansiReset)
+		}
 	}

-	configureOllamaWebSearch()
+	if strings.HasSuffix(model, ":cloud") || strings.HasSuffix(model, "-cloud") {
+		if ensureWebSearchPlugin() {
+			registerWebSearchPlugin()
+		}
+	}
+
+	if firstLaunch {
+		fmt.Fprintf(os.Stderr, "\n%sPreparing your assistant — this may take a moment...%s\n\n", ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(os.Stderr, "\n%sStarting your assistant — this may take a moment...%s\n\n", ansiGray, ansiReset)
+	}

 	// When extra args are passed through, run exactly what the user asked for
 	// after setup and skip the built-in gateway+TUI convenience flow.
 	if len(args) > 0 {
-		cleanup := func() {}
-		if shouldEnsureGatewayForArgs(args) {
-			cleanupFn, _, _, err := c.ensureGatewayReady(bin)
-			if err != nil {
-				return windowsHint(err)
-			}
-			if cleanupFn != nil {
-				cleanup = cleanupFn
-			}
-		}
-		defer cleanup()
-
 		cmd := exec.Command(bin, args...)
 		cmd.Env = openclawEnv()
 		cmd.Stdin = os.Stdin
@@ -116,23 +106,49 @@ func (c *Openclaw) Run(model string, _ []LaunchModel, args []string) error {
 		if err := cmd.Run(); err != nil {
 			return windowsHint(err)
 		}
+		if firstLaunch {
+			if err := integrationOnboarded("openclaw"); err != nil {
+				return fmt.Errorf("failed to save onboarding state: %w", err)
+			}
+		}
 		return nil
 	}

-	if err := c.runChannelSetupPreflight(bin); err != nil {
-		return err
-	}
-	// Keep local pairing scopes up to date before the gateway lifecycle
-	// (restart/start) regardless of channel preflight branch behavior.
-	patchDeviceScopes()
+	token, port := c.gatewayInfo()
+	addr := fmt.Sprintf("localhost:%d", port)

-	fmt.Fprintf(os.Stderr, "\n%sStarting your assistant — this may take a moment...%s\n\n", ansiGray, ansiReset)
-
-	cleanup, token, port, err := c.ensureGatewayReady(bin)
-	if err != nil {
-		return windowsHint(err)
+	// If the gateway is already running (e.g. via the daemon), restart it
+	// so it picks up any config changes from Edit() above (model, provider, etc.).
+	if portOpen(addr) {
+		restart := exec.Command(bin, "daemon", "restart")
+		restart.Env = openclawEnv()
+		if err := restart.Run(); err != nil {
+			fmt.Fprintf(os.Stderr, "%s  Warning: daemon restart failed: %v%s\n", ansiYellow, err, ansiReset)
+		}
+		if !waitForPort(addr, 10*time.Second) {
+			fmt.Fprintf(os.Stderr, "%s  Warning: gateway did not come back after restart%s\n", ansiYellow, ansiReset)
+		}
+	}
+
+	// If the gateway isn't running, start it as a background child process.
+	if !portOpen(addr) {
+		gw := exec.Command(bin, "gateway", "run", "--force")
+		gw.Env = openclawEnv()
+		if err := gw.Start(); err != nil {
+			return windowsHint(fmt.Errorf("failed to start gateway: %w", err))
+		}
+		defer func() {
+			if gw.Process != nil {
+				_ = gw.Process.Kill()
+				_ = gw.Wait()
+			}
+		}()
+	}
+
+	fmt.Fprintf(os.Stderr, "%sStarting gateway...%s\n", ansiGray, ansiReset)
+	if !waitForPort(addr, 30*time.Second) {
+		return windowsHint(fmt.Errorf("gateway did not start on %s", addr))
 	}
-	defer cleanup()

 	printOpenclawReady(bin, token, port, firstLaunch)

@@ -149,157 +165,14 @@ func (c *Openclaw) Run(model string, _ []LaunchModel, args []string) error {
 		return windowsHint(err)
 	}

+	if firstLaunch {
+		if err := integrationOnboarded("openclaw"); err != nil {
+			return fmt.Errorf("failed to save onboarding state: %w", err)
+		}
+	}
 	return nil
 }

-func shouldEnsureGatewayForArgs(args []string) bool {
-	return len(args) > 0 && args[0] == "tui"
-}
-
-func (c *Openclaw) ensureGatewayReady(bin string) (func(), string, int, error) {
-	token, port := c.gatewayInfo()
-	addr := fmt.Sprintf("127.0.0.1:%d", port)
-
-	// If the gateway is already running (e.g. via the daemon), restart it
-	// so it picks up any config changes (model, provider, etc.).
-	if portOpen(addr) {
-		restart := exec.Command(bin, "daemon", "restart")
-		restart.Env = openclawEnv()
-		if err := restart.Run(); err != nil {
-			fmt.Fprintf(os.Stderr, "%s  Warning: daemon restart failed: %v%s\n", ansiYellow, err, ansiReset)
-		}
-		if !waitForPort(addr, 10*time.Second) {
-			fmt.Fprintf(os.Stderr, "%s  Warning: gateway did not come back after restart%s\n", ansiYellow, ansiReset)
-		}
-	}
-
-	// If the daemon is installed but not currently listening, try to bring it
-	// up before falling back to a foreground child process.
-	if openclawCanInstallDaemon() && !portOpen(addr) {
-		start := exec.Command(bin, "daemon", "start")
-		start.Env = openclawEnv()
-		if err := start.Run(); err != nil {
-			fmt.Fprintf(os.Stderr, "%s  Warning: daemon start failed: %v%s\n", ansiYellow, err, ansiReset)
-		} else if waitForPort(addr, 10*time.Second) {
-			fmt.Fprintf(os.Stderr, "%sStarting gateway...%s\n", ansiGray, ansiReset)
-			return func() {}, token, port, nil
-		}
-	}
-
-	cleanup := func() {}
-
-	// If the gateway still isn't running, start it as a background child process.
-	if !portOpen(addr) {
-		gw := exec.Command(bin, "gateway", "run", "--force")
-		gw.Env = openclawEnv()
-		if err := gw.Start(); err != nil {
-			return nil, "", 0, fmt.Errorf("failed to start gateway: %w", err)
-		}
-		cleanup = func() {
-			if gw.Process != nil {
-				_ = gw.Process.Kill()
-				_ = gw.Wait()
-			}
-		}
-	}
-
-	fmt.Fprintf(os.Stderr, "%sStarting gateway...%s\n", ansiGray, ansiReset)
-	if !waitForPort(addr, 30*time.Second) {
-		cleanup()
-		return nil, "", 0, fmt.Errorf("gateway did not start on %s", addr)
-	}
-
-	return cleanup, token, port, nil
-}
-
-// runChannelSetupPreflight prompts users to connect a messaging channel before
-// starting the built-in gateway+TUI flow. In interactive sessions, it loops
-// until a channel is configured, unless the user chooses "Set up later".
-func (c *Openclaw) runChannelSetupPreflight(bin string) error {
-	if !isInteractiveSession() {
-		return nil
-	}
-	// --yes is headless; channel setup spawns an interactive picker we can't
-	// auto-answer, so skip it. Users can run `openclaw channels add` later.
-	if currentLaunchConfirmPolicy.yes {
-		return nil
-	}
-
-	for {
-		if c.channelsConfigured() {
-			return nil
-		}
-
-		fmt.Fprintf(os.Stderr, "\nYour assistant can message you on WhatsApp, Telegram, Discord, and more.\n\n")
-		ok, err := ConfirmPromptWithOptions("Connect a channel (messaging app) now?", ConfirmOptions{
-			YesLabel: "Yes",
-			NoLabel:  "Set up later",
-		})
-		if err != nil {
-			return err
-		}
-		if !ok {
-			return nil
-		}
-
-		cmd := exec.Command(bin, "channels", "add")
-		cmd.Env = openclawEnv()
-		cmd.Stdin = os.Stdin
-		cmd.Stdout = os.Stdout
-		cmd.Stderr = os.Stderr
-		if err := cmd.Run(); err != nil {
-			return windowsHint(fmt.Errorf("openclaw channel setup failed: %w\n\nTry running: %s channels add", err, bin))
-		}
-	}
-}
-
-// channelsConfigured reports whether local OpenClaw config contains at least
-// one meaningfully configured channel entry.
-func (c *Openclaw) channelsConfigured() bool {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return false
-	}
-
-	for _, path := range []string{
-		filepath.Join(home, ".openclaw", "openclaw.json"),
-		filepath.Join(home, ".clawdbot", "clawdbot.json"),
-	} {
-		data, err := os.ReadFile(path)
-		if err != nil {
-			continue
-		}
-
-		var cfg map[string]any
-		if json.Unmarshal(data, &cfg) != nil {
-			continue
-		}
-
-		channels, _ := cfg["channels"].(map[string]any)
-		if channels == nil {
-			return false
-		}
-
-		for key, value := range channels {
-			if key == "defaults" || key == "modelByChannel" {
-				continue
-			}
-			entry, ok := value.(map[string]any)
-			if !ok {
-				continue
-			}
-			for entryKey := range entry {
-				if entryKey != "enabled" {
-					return true
-				}
-			}
-		}
-		return false
-	}
-
-	return false
-}
-
 // gatewayInfo reads the gateway auth token and port from the OpenClaw config.
 func (c *Openclaw) gatewayInfo() (token string, port int) {
 	port = defaultGatewayPort
@@ -334,7 +207,7 @@ func (c *Openclaw) gatewayInfo() (token string, port int) {
 }

 func printOpenclawReady(bin, token string, port int, firstLaunch bool) {
-	u := fmt.Sprintf("http://127.0.0.1:%d", port)
+	u := fmt.Sprintf("http://localhost:%d", port)
 	if token != "" {
 		u += "/#token=" + url.QueryEscape(token)
 	}
@@ -346,9 +219,12 @@ func printOpenclawReady(bin, token string, port int, firstLaunch bool) {
 	if firstLaunch {
 		fmt.Fprintf(os.Stderr, "%s  Quick start:%s\n", ansiBold, ansiReset)
 		fmt.Fprintf(os.Stderr, "%s    /help             see all commands%s\n", ansiGray, ansiReset)
+		fmt.Fprintf(os.Stderr, "%s    %s configure --section channels   connect WhatsApp, Telegram, etc.%s\n", ansiGray, bin, ansiReset)
 		fmt.Fprintf(os.Stderr, "%s    %s skills                         browse and install skills%s\n\n", ansiGray, bin, ansiReset)
 		fmt.Fprintf(os.Stderr, "%s  The OpenClaw gateway is running in the background.%s\n", ansiYellow, ansiReset)
 		fmt.Fprintf(os.Stderr, "%s  Stop it with: %s gateway stop%s\n\n", ansiYellow, bin, ansiReset)
+	} else {
+		fmt.Fprintf(os.Stderr, "%sTip: connect WhatsApp, Telegram, and more with: %s configure --section channels%s\n", ansiGray, bin, ansiReset)
 	}
 }

@@ -372,30 +248,9 @@ func openclawEnv() []string {
 			env = append(env, e)
 		}
 	}
-	if _, ok := os.LookupEnv("OPENCLAW_PLUGIN_STAGE_DIR"); !ok {
-		if dir := openclawPluginStageDir(); dir != "" {
-			env = append(env, "OPENCLAW_PLUGIN_STAGE_DIR="+dir)
-		}
-	}
 	return env
 }

-func openclawInstallEnv() []string {
-	env := openclawEnv()
-	if _, ok := os.LookupEnv("OPENCLAW_EAGER_BUNDLED_PLUGIN_DEPS"); !ok {
-		env = append(env, "OPENCLAW_EAGER_BUNDLED_PLUGIN_DEPS=1")
-	}
-	return env
-}
-
-func openclawPluginStageDir() string {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return ""
-	}
-	return filepath.Join(home, ".openclaw", "plugin-runtime-deps")
-}
-
 // portOpen checks if a TCP port is currently accepting connections.
 func portOpen(addr string) bool {
 	conn, err := net.DialTimeout("tcp", addr, 500*time.Millisecond)
@@ -458,10 +313,9 @@ func (c *Openclaw) onboarded() bool {
 	return lastRunAt != ""
 }

-// patchDeviceScopes upgrades the local CLI device's paired operator scopes so
-// newer gateway auth baselines (approvedScopes) allow launch+TUI reconnects
-// without forcing an interactive re-pair. Only patches the local device,
-// not remote ones. Best-effort: silently returns on any error.
+// patchDeviceScopes upgrades the local CLI device's paired scopes to include
+// operator.admin. Only patches the local device, not remote ones.
+// Best-effort: silently returns on any error.
 func patchDeviceScopes() {
 	home, err := os.UserHomeDir()
 	if err != nil {
@@ -497,15 +351,9 @@ func patchDeviceScopes() {
 	}

 	changed := patchScopes(dev, "scopes", required)
-	if patchScopes(dev, "approvedScopes", required) {
-		changed = true
-	}
 	if tokens, ok := dev["tokens"].(map[string]any); ok {
-		for role, tok := range tokens {
+		for _, tok := range tokens {
 			if tokenMap, ok := tok.(map[string]any); ok {
-				if !isOperatorToken(role, tokenMap) {
-					continue
-				}
 				if patchScopes(tokenMap, "scopes", required) {
 					changed = true
 				}
@@ -561,33 +409,6 @@ func patchScopes(obj map[string]any, key string, required []string) bool {
 	return added
 }

-func isOperatorToken(tokenRole string, token map[string]any) bool {
-	if strings.EqualFold(strings.TrimSpace(tokenRole), "operator") {
-		return true
-	}
-	role, _ := token["role"].(string)
-	return strings.EqualFold(strings.TrimSpace(role), "operator")
-}
-
-// canInstallDaemon reports whether the openclaw daemon can be installed as a
-// background service. Returns false on Linux when systemd is absent (e.g.
-// containers) so that --install-daemon is omitted and the gateway is started
-// as a foreground child process instead. Returns true in all other cases.
-func canInstallDaemon() bool {
-	if runtime.GOOS != "linux" {
-		return true
-	}
-	// /run/systemd/system exists as a directory when systemd is the init system.
-	// This is absent in most containers.
-	fi, err := os.Stat("/run/systemd/system")
-	if err != nil || !fi.IsDir() {
-		return false
-	}
-	// Even when systemd is the init system, user services require a user
-	// manager instance. XDG_RUNTIME_DIR being set is a prerequisite.
-	return os.Getenv("XDG_RUNTIME_DIR") != ""
-}
-
 func ensureOpenclawInstalled() (string, error) {
 	if _, err := exec.LookPath("openclaw"); err == nil {
 		return "openclaw", nil
@@ -596,20 +417,16 @@ func ensureOpenclawInstalled() (string, error) {
 		return "clawdbot", nil
 	}

-	_, npmErr := exec.LookPath("npm")
-	_, gitErr := exec.LookPath("git")
-	if npmErr != nil || gitErr != nil {
-		var missing []string
-		if npmErr != nil {
-			missing = append(missing, "npm (Node.js): https://nodejs.org/")
-		}
-		if gitErr != nil {
-			missing = append(missing, "git: https://git-scm.com/")
-		}
-		return "", fmt.Errorf("OpenClaw is not installed and required dependencies are missing\n\nInstall the following first:\n  %s\n\nThen re-run:\n  ollama launch openclaw", strings.Join(missing, "\n  "))
+	if _, err := exec.LookPath("npm"); err != nil {
+		return "", fmt.Errorf("openclaw is not installed and npm was not found\n\n" +
+			"Install Node.js first:\n" +
+			"  https://nodejs.org/\n\n" +
+			"Then rerun:\n" +
+			"  ollama launch\n" +
+			"and select OpenClaw")
 	}

-	ok, err := ConfirmPrompt("OpenClaw is not installed. Install with npm?")
+	ok, err := confirmPrompt("OpenClaw is not installed. Install with npm?")
 	if err != nil {
 		return "", err
 	}
@@ -619,7 +436,6 @@ func ensureOpenclawInstalled() (string, error) {

 	fmt.Fprintf(os.Stderr, "\nInstalling OpenClaw...\n")
 	cmd := exec.Command("npm", "install", "-g", "openclaw@latest")
-	cmd.Env = openclawInstallEnv()
 	cmd.Stdin = os.Stdin
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
@@ -632,7 +448,6 @@ func ensureOpenclawInstalled() (string, error) {
 	}

 	fmt.Fprintf(os.Stderr, "%sOpenClaw installed successfully%s\n\n", ansiGreen, ansiReset)
-	openclawFreshInstall = true
 	return "openclaw", nil
 }

@@ -649,7 +464,7 @@ func (c *Openclaw) Paths() []string {
 	return nil
 }

-func (c *Openclaw) Edit(models []LaunchModel) error {
+func (c *Openclaw) Edit(models []string) error {
 	if len(models) == 0 {
 		return nil
 	}
@@ -687,7 +502,7 @@ func (c *Openclaw) Edit(models []LaunchModel) error {
 		ollama = make(map[string]any)
 	}

-	ollama["baseUrl"] = envconfig.Host().String()
+	ollama["baseUrl"] = envconfig.Host().String() + "/v1"
 	// needed to register provider
 	ollama["apiKey"] = "ollama-local"
 	ollama["api"] = "ollama"
@@ -703,11 +518,13 @@ func (c *Openclaw) Edit(models []LaunchModel) error {
 		}
 	}

+	client, _ := api.ClientFromEnvironment()
+
 	var newModels []any
 	for _, m := range models {
-		entry, _ := openclawModelConfig(m)
+		entry, _ := openclawModelConfig(context.Background(), client, m)
 		// Merge existing fields (user customizations)
-		if existing, ok := existingByID[m.Name]; ok {
+		if existing, ok := existingByID[m]; ok {
 			for k, v := range existing {
 				if _, isNew := entry[k]; !isNew {
 					entry[k] = v
@@ -735,7 +552,7 @@ func (c *Openclaw) Edit(models []LaunchModel) error {
 	if modelConfig == nil {
 		modelConfig = make(map[string]any)
 	}
-	modelConfig["primary"] = "ollama/" + models[0].Name
+	modelConfig["primary"] = "ollama/" + models[0]
 	defaults["model"] = modelConfig
 	agents["defaults"] = defaults
 	config["agents"] = agents
@@ -744,13 +561,13 @@ func (c *Openclaw) Edit(models []LaunchModel) error {
 	if err != nil {
 		return err
 	}
-	if err := fileutil.WriteWithBackup(configPath, data, "openclaw"); err != nil {
+	if err := writeWithBackup(configPath, data); err != nil {
 		return err
 	}

 	// Clear any per-session model overrides so the new primary takes effect
 	// immediately rather than being shadowed by a cached modelOverride.
-	clearSessionModelOverride(models[0].Name)
+	clearSessionModelOverride(models[0])
 	return nil
 }

@@ -775,8 +592,6 @@ func clearSessionModelOverride(primary string) {
 		if override, _ := sess["modelOverride"].(string); override != "" && override != primary {
 			delete(sess, "modelOverride")
 			delete(sess, "providerOverride")
-		}
-		if model, _ := sess["model"].(string); model != "" && model != primary {
 			sess["model"] = primary
 			changed = true
 		}
@@ -791,13 +606,57 @@ func clearSessionModelOverride(primary string) {
 	_ = os.WriteFile(path, out, 0o600)
 }

-// configureOllamaWebSearch keeps launch-managed OpenClaw installs on the
-// bundled Ollama web_search provider. Older launch builds installed an
-// external openclaw-web-search plugin that added custom ollama_web_search and
-// ollama_web_fetch tools. Current OpenClaw versions ship Ollama web_search as
-// the bundled "ollama" plugin instead, so we migrate stale config and ensure
-// fresh installs select the bundled provider.
-func configureOllamaWebSearch() {
+const webSearchNpmPackage = "@ollama/openclaw-web-search"
+
+// ensureWebSearchPlugin installs the openclaw-web-search extension into the
+// user-level extensions directory (~/.openclaw/extensions/) if it isn't already
+// present. Returns true if the extension is available.
+func ensureWebSearchPlugin() bool {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return false
+	}
+
+	pluginDir := filepath.Join(home, ".openclaw", "extensions", "openclaw-web-search")
+	if _, err := os.Stat(filepath.Join(pluginDir, "index.ts")); err == nil {
+		return true // already installed
+	}
+
+	npmBin, err := exec.LookPath("npm")
+	if err != nil {
+		return false
+	}
+
+	if err := os.MkdirAll(pluginDir, 0o755); err != nil {
+		return false
+	}
+
+	// Download the tarball via `npm pack`, extract it flat into the plugin dir.
+	pack := exec.Command(npmBin, "pack", webSearchNpmPackage, "--pack-destination", pluginDir)
+	out, err := pack.Output()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "%s  Warning: could not download web search plugin: %v%s\n", ansiYellow, err, ansiReset)
+		return false
+	}
+
+	tgzName := strings.TrimSpace(string(out))
+	tgzPath := filepath.Join(pluginDir, tgzName)
+	defer os.Remove(tgzPath)
+
+	tar := exec.Command("tar", "xzf", tgzPath, "--strip-components=1", "-C", pluginDir)
+	if err := tar.Run(); err != nil {
+		fmt.Fprintf(os.Stderr, "%s  Warning: could not extract web search plugin: %v%s\n", ansiYellow, err, ansiReset)
+		return false
+	}
+
+	fmt.Fprintf(os.Stderr, "%s  ✓ Installed web search plugin%s\n", ansiGreen, ansiReset)
+	return true
+}
+
+// registerWebSearchPlugin adds plugins.entries.openclaw-web-search to the OpenClaw
+// config so the gateway activates it on next start. Best-effort; silently returns
+// on any error.
+func registerWebSearchPlugin() {
 	home, err := os.UserHomeDir()
 	if err != nil {
 		return
@@ -812,8 +671,6 @@ func configureOllamaWebSearch() {
 		return
 	}

-	stalePluginConfigured := false
-
 	plugins, _ := config["plugins"].(map[string]any)
 	if plugins == nil {
 		plugins = make(map[string]any)
@@ -822,6 +679,14 @@ func configureOllamaWebSearch() {
 	if entries == nil {
 		entries = make(map[string]any)
 	}
+	if _, ok := entries["openclaw-web-search"]; ok {
+		return // already registered
+	}
+	entries["openclaw-web-search"] = map[string]any{"enabled": true}
+	plugins["entries"] = entries
+	config["plugins"] = plugins
+
+	// Disable the built-in web search since our plugin replaces it.
 	tools, _ := config["tools"].(map[string]any)
 	if tools == nil {
 		tools = make(map[string]any)
@@ -830,92 +695,8 @@ func configureOllamaWebSearch() {
 	if web == nil {
 		web = make(map[string]any)
 	}
-	search, _ := web["search"].(map[string]any)
-	if search == nil {
-		search = make(map[string]any)
-	}
-	fetch, _ := web["fetch"].(map[string]any)
-	if fetch == nil {
-		fetch = make(map[string]any)
-	}
-
-	alsoAllow, _ := tools["alsoAllow"].([]any)
-	var filteredAlsoAllow []any
-	for _, v := range alsoAllow {
-		s, ok := v.(string)
-		if !ok {
-			filteredAlsoAllow = append(filteredAlsoAllow, v)
-			continue
-		}
-		if s == "ollama_web_search" || s == "ollama_web_fetch" {
-			stalePluginConfigured = true
-			continue
-		}
-		filteredAlsoAllow = append(filteredAlsoAllow, v)
-	}
-	if len(filteredAlsoAllow) > 0 {
-		tools["alsoAllow"] = filteredAlsoAllow
-	} else {
-		delete(tools, "alsoAllow")
-	}
-
-	if _, ok := entries["openclaw-web-search"]; ok {
-		delete(entries, "openclaw-web-search")
-		stalePluginConfigured = true
-	}
-	ollamaEntry, _ := entries["ollama"].(map[string]any)
-	if ollamaEntry == nil {
-		ollamaEntry = make(map[string]any)
-	}
-	ollamaEntry["enabled"] = true
-	entries["ollama"] = ollamaEntry
-	plugins["entries"] = entries
-
-	if allow, ok := plugins["allow"].([]any); ok {
-		var nextAllow []any
-		hasOllama := false
-		for _, v := range allow {
-			s, ok := v.(string)
-			if ok && s == "openclaw-web-search" {
-				stalePluginConfigured = true
-				continue
-			}
-			if ok && s == "ollama" {
-				hasOllama = true
-			}
-			nextAllow = append(nextAllow, v)
-		}
-		if !hasOllama {
-			nextAllow = append(nextAllow, "ollama")
-		}
-		plugins["allow"] = nextAllow
-	}
-
-	if installs, ok := plugins["installs"].(map[string]any); ok {
-		if _, exists := installs["openclaw-web-search"]; exists {
-			delete(installs, "openclaw-web-search")
-			stalePluginConfigured = true
-		}
-		if len(installs) > 0 {
-			plugins["installs"] = installs
-		} else {
-			delete(plugins, "installs")
-		}
-	}
-
-	if stalePluginConfigured || search["provider"] == nil {
-		search["provider"] = "ollama"
-	}
-	if stalePluginConfigured {
-		fetch["enabled"] = true
-	}
-	search["enabled"] = true
-	web["search"] = search
-	if len(fetch) > 0 {
-		web["fetch"] = fetch
-	}
+	web["search"] = map[string]any{"enabled": false}
 	tools["web"] = web
-	config["plugins"] = plugins
 	config["tools"] = tools

 	out, err := json.MarshalIndent(config, "", "  ")
@@ -927,10 +708,10 @@ func configureOllamaWebSearch() {

 // openclawModelConfig builds an OpenClaw model config entry with capability detection.
 // The second return value indicates whether the model is a cloud (remote) model.
-func openclawModelConfig(model LaunchModel) (map[string]any, bool) {
+func openclawModelConfig(ctx context.Context, client *api.Client, modelID string) (map[string]any, bool) {
 	entry := map[string]any{
-		"id":    model.Name,
-		"name":  model.Name,
+		"id":    modelID,
+		"name":  modelID,
 		"input": []any{"text"},
 		"cost": map[string]any{
 			"input":      0,
@@ -940,24 +721,53 @@ func openclawModelConfig(model LaunchModel) (map[string]any, bool) {
 		},
 	}

+	if client == nil {
+		return entry, false
+	}
+
+	showCtx := ctx
+	if _, hasDeadline := ctx.Deadline(); !hasDeadline {
+		var cancel context.CancelFunc
+		showCtx, cancel = context.WithTimeout(ctx, openclawModelShowTimeout)
+		defer cancel()
+	}
+
+	resp, err := client.Show(showCtx, &api.ShowRequest{Model: modelID})
+	if err != nil {
+		return entry, false
+	}
+
 	// Set input types based on vision capability
-	if model.HasCapability("vision") {
+	if slices.Contains(resp.Capabilities, model.CapabilityVision) {
 		entry["input"] = []any{"text", "image"}
 	}

 	// Set reasoning based on thinking capability
-	if model.HasCapability("thinking") {
+	if slices.Contains(resp.Capabilities, model.CapabilityThinking) {
 		entry["reasoning"] = true
 	}

-	if model.ContextLength > 0 {
-		entry["contextWindow"] = model.ContextLength
-	}
-	if model.MaxOutputTokens > 0 {
-		entry["maxTokens"] = model.MaxOutputTokens
+	// Cloud models: use hardcoded limits for context/output tokens.
+	// Capability detection above still applies (vision, thinking).
+	if resp.RemoteModel != "" {
+		if l, ok := lookupCloudModelLimit(modelID); ok {
+			entry["contextWindow"] = l.Context
+			entry["maxTokens"] = l.Output
+		}
+		return entry, true
 	}

-	return entry, model.Remote || isCloudModelName(model.Name)
+	// Extract context window from ModelInfo (local models only)
+	for key, val := range resp.ModelInfo {
+		if strings.HasSuffix(key, ".context_length") {
+			if ctxLen, ok := val.(float64); ok && ctxLen > 0 {
+				entry["contextWindow"] = int(ctxLen)
+			}
+			break
+		}
+	}
+
+	return entry, false
 }

 func (c *Openclaw) Models() []string {
@@ -966,9 +776,9 @@ func (c *Openclaw) Models() []string {
 		return nil
 	}

-	config, err := fileutil.ReadJSON(filepath.Join(home, ".openclaw", "openclaw.json"))
+	config, err := readJSONFile(filepath.Join(home, ".openclaw", "openclaw.json"))
 	if err != nil {
-		config, err = fileutil.ReadJSON(filepath.Join(home, ".clawdbot", "clawdbot.json"))
+		config, err = readJSONFile(filepath.Join(home, ".clawdbot", "clawdbot.json"))
 		if err != nil {
 			return nil
 		}
@@ -0,0 +1,279 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"maps"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+)
+
+// OpenCode implements Runner and Editor for OpenCode integration
+type OpenCode struct{}
+
+// cloudModelLimit holds context and output token limits for a cloud model.
+type cloudModelLimit struct {
+	Context int
+	Output  int
+}
+
+// lookupCloudModelLimit returns the token limits for a cloud model.
+// It tries the exact name first, then strips the ":cloud" suffix.
+func lookupCloudModelLimit(name string) (cloudModelLimit, bool) {
+	if l, ok := cloudModelLimits[name]; ok {
+		return l, true
+	}
+	base := strings.TrimSuffix(name, ":cloud")
+	if base != name {
+		if l, ok := cloudModelLimits[base]; ok {
+			return l, true
+		}
+	}
+	return cloudModelLimit{}, false
+}
+
+func (o *OpenCode) String() string { return "OpenCode" }
+
+func (o *OpenCode) Run(model string, args []string) error {
+	if _, err := exec.LookPath("opencode"); err != nil {
+		return fmt.Errorf("opencode is not installed, install from https://opencode.ai")
+	}
+
+	// Call Edit() to ensure config is up-to-date before launch
+	models := []string{model}
+	if config, err := loadIntegration("opencode"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	var err error
+	models, err = resolveEditorModels("opencode", models, func() ([]string, error) {
+		return selectModels(context.Background(), "opencode", "")
+	})
+	if errors.Is(err, errCancelled) {
+		return nil
+	}
+	if err != nil {
+		return err
+	}
+	if err := o.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
+	cmd := exec.Command("opencode", args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func (o *OpenCode) Paths() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	var paths []string
+	p := filepath.Join(home, ".config", "opencode", "opencode.json")
+	if _, err := os.Stat(p); err == nil {
+		paths = append(paths, p)
+	}
+	sp := filepath.Join(home, ".local", "state", "opencode", "model.json")
+	if _, err := os.Stat(sp); err == nil {
+		paths = append(paths, sp)
+	}
+	return paths
+}
+
+func (o *OpenCode) Edit(modelList []string) error {
+	if len(modelList) == 0 {
+		return nil
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	configPath := filepath.Join(home, ".config", "opencode", "opencode.json")
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		_ = json.Unmarshal(data, &config) // Ignore parse errors; treat missing/corrupt files as empty
+	}
+
+	config["$schema"] = "https://opencode.ai/config.json"
+
+	provider, ok := config["provider"].(map[string]any)
+	if !ok {
+		provider = make(map[string]any)
+	}
+
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		ollama = map[string]any{
+			"npm":  "@ai-sdk/openai-compatible",
+			"name": "Ollama (local)",
+			"options": map[string]any{
+				"baseURL": envconfig.Host().String() + "/v1",
+			},
+		}
+	}
+
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		models = make(map[string]any)
+	}
+
+	selectedSet := make(map[string]bool)
+	for _, m := range modelList {
+		selectedSet[m] = true
+	}
+
+	for name, cfg := range models {
+		if cfgMap, ok := cfg.(map[string]any); ok {
+			if isOllamaModel(cfgMap) && !selectedSet[name] {
+				delete(models, name)
+			}
+		}
+	}
+
+	client, _ := api.ClientFromEnvironment()
+
+	for _, model := range modelList {
+		if existing, ok := models[model].(map[string]any); ok {
+			// migrate existing models without _launch marker
+			if isOllamaModel(existing) {
+				existing["_launch"] = true
+				if name, ok := existing["name"].(string); ok {
+					existing["name"] = strings.TrimSuffix(name, " [Ollama]")
+				}
+			}
+			if isCloudModel(context.Background(), client, model) {
+				if l, ok := lookupCloudModelLimit(model); ok {
+					existing["limit"] = map[string]any{
+						"context": l.Context,
+						"output":  l.Output,
+					}
+				}
+			}
+			continue
+		}
+		entry := map[string]any{
+			"name":    model,
+			"_launch": true,
+		}
+		if isCloudModel(context.Background(), client, model) {
+			if l, ok := lookupCloudModelLimit(model); ok {
+				entry["limit"] = map[string]any{
+					"context": l.Context,
+					"output":  l.Output,
+				}
+			}
+		}
+		models[model] = entry
+	}
+
+	ollama["models"] = models
+	provider["ollama"] = ollama
+	config["provider"] = provider
+
+	configData, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	if err := writeWithBackup(configPath, configData); err != nil {
+		return err
+	}
+
+	statePath := filepath.Join(home, ".local", "state", "opencode", "model.json")
+	if err := os.MkdirAll(filepath.Dir(statePath), 0o755); err != nil {
+		return err
+	}
+
+	state := map[string]any{
+		"recent":   []any{},
+		"favorite": []any{},
+		"variant":  map[string]any{},
+	}
+	if data, err := os.ReadFile(statePath); err == nil {
+		_ = json.Unmarshal(data, &state) // Ignore parse errors; use defaults
+	}
+
+	recent, _ := state["recent"].([]any)
+
+	modelSet := make(map[string]bool)
+	for _, m := range modelList {
+		modelSet[m] = true
+	}
+
+	// Filter out existing Ollama models we're about to re-add
+	newRecent := slices.DeleteFunc(slices.Clone(recent), func(entry any) bool {
+		e, ok := entry.(map[string]any)
+		if !ok || e["providerID"] != "ollama" {
+			return false
+		}
+		modelID, _ := e["modelID"].(string)
+		return modelSet[modelID]
+	})
+
+	// Prepend models in reverse order so first model ends up first
+	for _, model := range slices.Backward(modelList) {
+		newRecent = slices.Insert(newRecent, 0, any(map[string]any{
+			"providerID": "ollama",
+			"modelID":    model,
+		}))
+	}
+
+	const maxRecentModels = 10
+	newRecent = newRecent[:min(len(newRecent), maxRecentModels)]
+
+	state["recent"] = newRecent
+
+	stateData, err := json.MarshalIndent(state, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(statePath, stateData)
+}
+
+func (o *OpenCode) Models() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+	config, err := readJSONFile(filepath.Join(home, ".config", "opencode", "opencode.json"))
+	if err != nil {
+		return nil
+	}
+	provider, _ := config["provider"].(map[string]any)
+	ollama, _ := provider["ollama"].(map[string]any)
+	models, _ := ollama["models"].(map[string]any)
+	if len(models) == 0 {
+		return nil
+	}
+	keys := slices.Collect(maps.Keys(models))
+	slices.Sort(keys)
+	return keys
+}
+
+// isOllamaModel reports whether a model config entry is managed by us
+func isOllamaModel(cfg map[string]any) bool {
+	if v, ok := cfg["_launch"].(bool); ok && v {
+		return true
+	}
+	// previously used [Ollama] as a suffix for the model managed by ollama launch
+	if name, ok := cfg["name"].(string); ok {
+		return strings.HasSuffix(name, "[Ollama]")
+	}
+	return false
+}
@@ -0,0 +1,668 @@
+package config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestOpenCodeIntegration(t *testing.T) {
+	o := &OpenCode{}
+
+	t.Run("String", func(t *testing.T) {
+		if got := o.String(); got != "OpenCode" {
+			t.Errorf("String() = %q, want %q", got, "OpenCode")
+		}
+	})
+
+	t.Run("implements Runner", func(t *testing.T) {
+		var _ Runner = o
+	})
+
+	t.Run("implements Editor", func(t *testing.T) {
+		var _ Editor = o
+	})
+}
+
+func TestOpenCodeEdit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	cleanup := func() {
+		os.RemoveAll(configDir)
+		os.RemoveAll(stateDir)
+	}
+
+	t.Run("fresh install", func(t *testing.T) {
+		cleanup()
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+	})
+
+	t.Run("preserve other providers", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"anthropic":{"apiKey":"xxx"}}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		if provider["anthropic"] == nil {
+			t.Error("anthropic provider was removed")
+		}
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("preserve other models", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"mistral":{"name":"Mistral"}}}}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeModelExists(t, configPath, "mistral")
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("update existing model", func(t *testing.T) {
+		cleanup()
+		o.Edit([]string{"llama3.2"})
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+	})
+
+	t.Run("preserve top-level keys", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"theme":"dark","keybindings":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		if cfg["theme"] != "dark" {
+			t.Error("theme was removed")
+		}
+		if cfg["keybindings"] == nil {
+			t.Error("keybindings was removed")
+		}
+	})
+
+	t.Run("model state - insert at index 0", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[{"providerID":"anthropic","modelID":"claude"}],"favorite":[],"variant":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+		assertOpenCodeRecentModel(t, statePath, 1, "anthropic", "claude")
+	})
+
+	t.Run("model state - preserve favorites and variants", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[],"favorite":[{"providerID":"x","modelID":"y"}],"variant":{"a":"b"}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(statePath)
+		var state map[string]any
+		json.Unmarshal(data, &state)
+		if len(state["favorite"].([]any)) != 1 {
+			t.Error("favorite was modified")
+		}
+		if state["variant"].(map[string]any)["a"] != "b" {
+			t.Error("variant was modified")
+		}
+	})
+
+	t.Run("model state - deduplicate on re-add", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(stateDir, 0o755)
+		os.WriteFile(statePath, []byte(`{"recent":[{"providerID":"ollama","modelID":"llama3.2"},{"providerID":"anthropic","modelID":"claude"}],"favorite":[],"variant":{}}`), 0o644)
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+		data, _ := os.ReadFile(statePath)
+		var state map[string]any
+		json.Unmarshal(data, &state)
+		recent := state["recent"].([]any)
+		if len(recent) != 2 {
+			t.Errorf("expected 2 recent entries, got %d", len(recent))
+		}
+		assertOpenCodeRecentModel(t, statePath, 0, "ollama", "llama3.2")
+	})
+
+	t.Run("remove model", func(t *testing.T) {
+		cleanup()
+		// First add two models
+		o.Edit([]string{"llama3.2", "mistral"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelExists(t, configPath, "mistral")
+
+		// Then remove one by only selecting the other
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelNotExists(t, configPath, "mistral")
+	})
+
+	t.Run("preserve user customizations on managed models", func(t *testing.T) {
+		cleanup()
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		// Add custom fields to the model entry (simulating user edits)
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		ollama := provider["ollama"].(map[string]any)
+		models := ollama["models"].(map[string]any)
+		entry := models["llama3.2"].(map[string]any)
+		entry["_myPref"] = "custom-value"
+		entry["_myNum"] = 42
+		configData, _ := json.MarshalIndent(cfg, "", "  ")
+		os.WriteFile(configPath, configData, 0o644)
+
+		// Re-run Edit — should preserve custom fields
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ = os.ReadFile(configPath)
+		json.Unmarshal(data, &cfg)
+		provider = cfg["provider"].(map[string]any)
+		ollama = provider["ollama"].(map[string]any)
+		models = ollama["models"].(map[string]any)
+		entry = models["llama3.2"].(map[string]any)
+
+		if entry["_myPref"] != "custom-value" {
+			t.Errorf("_myPref was lost: got %v", entry["_myPref"])
+		}
+		if entry["_myNum"] != float64(42) {
+			t.Errorf("_myNum was lost: got %v", entry["_myNum"])
+		}
+		if v, ok := entry["_launch"].(bool); !ok || !v {
+			t.Errorf("_launch marker missing or false: got %v", entry["_launch"])
+		}
+	})
+
+	t.Run("migrate legacy [Ollama] suffix entries", func(t *testing.T) {
+		cleanup()
+		// Write a config with a legacy entry (has [Ollama] suffix but no _launch marker)
+		os.MkdirAll(configDir, 0o755)
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"llama3.2":{"name":"llama3.2 [Ollama]"}}}}}`), 0o644)
+
+		if err := o.Edit([]string{"llama3.2"}); err != nil {
+			t.Fatal(err)
+		}
+
+		data, _ := os.ReadFile(configPath)
+		var cfg map[string]any
+		json.Unmarshal(data, &cfg)
+		provider := cfg["provider"].(map[string]any)
+		ollama := provider["ollama"].(map[string]any)
+		models := ollama["models"].(map[string]any)
+		entry := models["llama3.2"].(map[string]any)
+
+		// _launch marker should be added
+		if v, ok := entry["_launch"].(bool); !ok || !v {
+			t.Errorf("_launch marker not added during migration: got %v", entry["_launch"])
+		}
+		// [Ollama] suffix should be stripped
+		if name, ok := entry["name"].(string); !ok || name != "llama3.2" {
+			t.Errorf("name suffix not stripped: got %q", entry["name"])
+		}
+	})
+
+	t.Run("remove model preserves non-ollama models", func(t *testing.T) {
+		cleanup()
+		os.MkdirAll(configDir, 0o755)
+		// Add a non-Ollama model manually
+		os.WriteFile(configPath, []byte(`{"provider":{"ollama":{"models":{"external":{"name":"External Model"}}}}}`), 0o644)
+
+		o.Edit([]string{"llama3.2"})
+		assertOpenCodeModelExists(t, configPath, "llama3.2")
+		assertOpenCodeModelExists(t, configPath, "external") // Should be preserved
+	})
+}
+
+func assertOpenCodeModelExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatal(err)
+	}
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		t.Fatal("provider not found")
+	}
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		t.Fatal("ollama provider not found")
+	}
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		t.Fatal("models not found")
+	}
+	if models[model] == nil {
+		t.Errorf("model %s not found", model)
+	}
+}
+
+func assertOpenCodeModelNotExists(t *testing.T, path, model string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatal(err)
+	}
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		return // No provider means no model
+	}
+	ollama, ok := provider["ollama"].(map[string]any)
+	if !ok {
+		return // No ollama means no model
+	}
+	models, ok := ollama["models"].(map[string]any)
+	if !ok {
+		return // No models means no model
+	}
+	if models[model] != nil {
+		t.Errorf("model %s should not exist but was found", model)
+	}
+}
+
+func assertOpenCodeRecentModel(t *testing.T, path string, index int, providerID, modelID string) {
+	t.Helper()
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var state map[string]any
+	if err := json.Unmarshal(data, &state); err != nil {
+		t.Fatal(err)
+	}
+	recent, ok := state["recent"].([]any)
+	if !ok {
+		t.Fatal("recent not found")
+	}
+	if index >= len(recent) {
+		t.Fatalf("index %d out of range (len=%d)", index, len(recent))
+	}
+	entry, ok := recent[index].(map[string]any)
+	if !ok {
+		t.Fatal("entry is not a map")
+	}
+	if entry["providerID"] != providerID {
+		t.Errorf("expected providerID %s, got %s", providerID, entry["providerID"])
+	}
+	if entry["modelID"] != modelID {
+		t.Errorf("expected modelID %s, got %s", modelID, entry["modelID"])
+	}
+}
+
+// Edge case tests for opencode.go
+
+func TestOpenCodeEdit_CorruptedConfigJSON(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{corrupted json content`), 0o644)
+
+	// Should not panic - corrupted JSON should be treated as empty
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit failed with corrupted config: %v", err)
+	}
+
+	// Verify valid JSON was created
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Errorf("resulting config is not valid JSON: %v", err)
+	}
+}
+
+func TestOpenCodeEdit_CorruptedStateJSON(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	os.MkdirAll(stateDir, 0o755)
+	os.WriteFile(statePath, []byte(`{corrupted state`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit failed with corrupted state: %v", err)
+	}
+
+	// Verify valid state was created
+	data, _ := os.ReadFile(statePath)
+	var state map[string]any
+	if err := json.Unmarshal(data, &state); err != nil {
+		t.Errorf("resulting state is not valid JSON: %v", err)
+	}
+}
+
+func TestOpenCodeEdit_WrongTypeProvider(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{"provider": "not a map"}`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit with wrong type provider failed: %v", err)
+	}
+
+	// Verify provider is now correct type
+	data, _ := os.ReadFile(configPath)
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+
+	provider, ok := cfg["provider"].(map[string]any)
+	if !ok {
+		t.Fatalf("provider should be map after setup, got %T", cfg["provider"])
+	}
+	if provider["ollama"] == nil {
+		t.Error("ollama provider should be created")
+	}
+}
+
+func TestOpenCodeEdit_WrongTypeRecent(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	stateDir := filepath.Join(tmpDir, ".local", "state", "opencode")
+	statePath := filepath.Join(stateDir, "model.json")
+
+	os.MkdirAll(stateDir, 0o755)
+	os.WriteFile(statePath, []byte(`{"recent": "not an array", "favorite": [], "variant": {}}`), 0o644)
+
+	err := o.Edit([]string{"llama3.2"})
+	if err != nil {
+		t.Fatalf("Edit with wrong type recent failed: %v", err)
+	}
+
+	// The function should handle this gracefully
+	data, _ := os.ReadFile(statePath)
+	var state map[string]any
+	json.Unmarshal(data, &state)
+
+	// recent should be properly set after setup
+	recent, ok := state["recent"].([]any)
+	if !ok {
+		t.Logf("Note: recent type after setup is %T (documenting behavior)", state["recent"])
+	} else if len(recent) == 0 {
+		t.Logf("Note: recent is empty (documenting behavior)")
+	}
+}
+
+func TestOpenCodeEdit_EmptyModels(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	os.MkdirAll(configDir, 0o755)
+	originalContent := `{"provider":{"ollama":{"models":{"existing":{}}}}}`
+	os.WriteFile(configPath, []byte(originalContent), 0o644)
+
+	// Empty models should be no-op
+	err := o.Edit([]string{})
+	if err != nil {
+		t.Fatalf("Edit with empty models failed: %v", err)
+	}
+
+	// Original content should be preserved (file not modified)
+	data, _ := os.ReadFile(configPath)
+	if string(data) != originalContent {
+		t.Errorf("empty models should not modify file, but content changed")
+	}
+}
+
+func TestOpenCodeEdit_SpecialCharsInModelName(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	// Model name with special characters (though unusual)
+	specialModel := `model-with-"quotes"`
+
+	err := o.Edit([]string{specialModel})
+	if err != nil {
+		t.Fatalf("Edit with special chars failed: %v", err)
+	}
+
+	// Verify it was stored correctly
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+	data, _ := os.ReadFile(configPath)
+
+	var cfg map[string]any
+	if err := json.Unmarshal(data, &cfg); err != nil {
+		t.Fatalf("resulting config is invalid JSON: %v", err)
+	}
+
+	// Model should be accessible
+	provider, _ := cfg["provider"].(map[string]any)
+	ollama, _ := provider["ollama"].(map[string]any)
+	models, _ := ollama["models"].(map[string]any)
+
+	if models[specialModel] == nil {
+		t.Errorf("model with special chars not found in config")
+	}
+}
+
+func readOpenCodeModel(t *testing.T, configPath, model string) map[string]any {
+	t.Helper()
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cfg map[string]any
+	json.Unmarshal(data, &cfg)
+	provider := cfg["provider"].(map[string]any)
+	ollama := provider["ollama"].(map[string]any)
+	models := ollama["models"].(map[string]any)
+	entry, ok := models[model].(map[string]any)
+	if !ok {
+		t.Fatalf("model %s not found in config", model)
+	}
+	return entry
+}
+
+func TestOpenCodeEdit_LocalModelNoLimit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configPath := filepath.Join(tmpDir, ".config", "opencode", "opencode.json")
+
+	if err := o.Edit([]string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "llama3.2")
+	if entry["limit"] != nil {
+		t.Errorf("local model should not have limit set, got %v", entry["limit"])
+	}
+}
+
+func TestOpenCodeEdit_PreservesUserLimit(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	// Set up a model with a user-configured limit
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(`{
+		"provider": {
+			"ollama": {
+				"models": {
+					"llama3.2": {
+						"name": "llama3.2",
+						"_launch": true,
+						"limit": {"context": 8192, "output": 4096}
+					}
+				}
+			}
+		}
+	}`), 0o644)
+
+	// Re-edit should preserve the user's limit (not delete it)
+	if err := o.Edit([]string{"llama3.2"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "llama3.2")
+	limit, ok := entry["limit"].(map[string]any)
+	if !ok {
+		t.Fatal("user-configured limit was removed")
+	}
+	if limit["context"] != float64(8192) {
+		t.Errorf("context limit changed: got %v, want 8192", limit["context"])
+	}
+	if limit["output"] != float64(4096) {
+		t.Errorf("output limit changed: got %v, want 4096", limit["output"])
+	}
+}
+
+func TestOpenCodeEdit_CloudModelLimitStructure(t *testing.T) {
+	// Verify that when a cloud model entry has limits set (as Edit would do),
+	// the structure matches what opencode expects and re-edit preserves them.
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	configDir := filepath.Join(tmpDir, ".config", "opencode")
+	configPath := filepath.Join(configDir, "opencode.json")
+
+	expected := cloudModelLimits["glm-4.7"]
+
+	// Simulate a cloud model that already has the limit set by a previous Edit
+	os.MkdirAll(configDir, 0o755)
+	os.WriteFile(configPath, []byte(fmt.Sprintf(`{
+		"provider": {
+			"ollama": {
+				"models": {
+					"glm-4.7:cloud": {
+						"name": "glm-4.7:cloud",
+						"_launch": true,
+						"limit": {"context": %d, "output": %d}
+					}
+				}
+			}
+		}
+	}`, expected.Context, expected.Output)), 0o644)
+
+	// Re-edit should preserve the cloud model limit
+	if err := o.Edit([]string{"glm-4.7:cloud"}); err != nil {
+		t.Fatal(err)
+	}
+
+	entry := readOpenCodeModel(t, configPath, "glm-4.7:cloud")
+	limit, ok := entry["limit"].(map[string]any)
+	if !ok {
+		t.Fatal("cloud model limit was removed on re-edit")
+	}
+	if limit["context"] != float64(expected.Context) {
+		t.Errorf("context = %v, want %d", limit["context"], expected.Context)
+	}
+	if limit["output"] != float64(expected.Output) {
+		t.Errorf("output = %v, want %d", limit["output"], expected.Output)
+	}
+}
+
+func TestLookupCloudModelLimit(t *testing.T) {
+	tests := []struct {
+		name        string
+		wantOK      bool
+		wantContext int
+		wantOutput  int
+	}{
+		{"glm-4.7", true, 202_752, 131_072},
+		{"glm-4.7:cloud", true, 202_752, 131_072},
+		{"kimi-k2.5", true, 262_144, 262_144},
+		{"kimi-k2.5:cloud", true, 262_144, 262_144},
+		{"deepseek-v3.2", true, 163_840, 65_536},
+		{"deepseek-v3.2:cloud", true, 163_840, 65_536},
+		{"qwen3-coder:480b", true, 262_144, 65_536},
+		{"qwen3-coder-next:cloud", true, 262_144, 32_768},
+		{"llama3.2", false, 0, 0},
+		{"unknown-model:cloud", false, 0, 0},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			l, ok := lookupCloudModelLimit(tt.name)
+			if ok != tt.wantOK {
+				t.Errorf("lookupCloudModelLimit(%q) ok = %v, want %v", tt.name, ok, tt.wantOK)
+			}
+			if ok {
+				if l.Context != tt.wantContext {
+					t.Errorf("context = %d, want %d", l.Context, tt.wantContext)
+				}
+				if l.Output != tt.wantOutput {
+					t.Errorf("output = %d, want %d", l.Output, tt.wantOutput)
+				}
+			}
+		})
+	}
+}
+
+func TestOpenCodeModels_NoConfig(t *testing.T) {
+	o := &OpenCode{}
+	tmpDir := t.TempDir()
+	setTestHome(t, tmpDir)
+
+	models := o.Models()
+	if len(models) > 0 {
+		t.Errorf("expected nil/empty for missing config, got %v", models)
+	}
+}
@@ -0,0 +1,237 @@
+package config
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"slices"
+	"strings"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/envconfig"
+	"github.com/ollama/ollama/types/model"
+)
+
+// Pi implements Runner and Editor for Pi (Pi Coding Agent) integration
+type Pi struct{}
+
+func (p *Pi) String() string { return "Pi" }
+
+func (p *Pi) Run(model string, args []string) error {
+	if _, err := exec.LookPath("pi"); err != nil {
+		return fmt.Errorf("pi is not installed, install with: npm install -g @mariozechner/pi-coding-agent")
+	}
+
+	// Call Edit() to ensure config is up-to-date before launch
+	models := []string{model}
+	if config, err := loadIntegration("pi"); err == nil && len(config.Models) > 0 {
+		models = config.Models
+	}
+	if err := p.Edit(models); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+
+	cmd := exec.Command("pi", args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+func (p *Pi) Paths() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	var paths []string
+	modelsPath := filepath.Join(home, ".pi", "agent", "models.json")
+	if _, err := os.Stat(modelsPath); err == nil {
+		paths = append(paths, modelsPath)
+	}
+	settingsPath := filepath.Join(home, ".pi", "agent", "settings.json")
+	if _, err := os.Stat(settingsPath); err == nil {
+		paths = append(paths, settingsPath)
+	}
+	return paths
+}
+
+func (p *Pi) Edit(models []string) error {
+	if len(models) == 0 {
+		return nil
+	}
+
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+
+	configPath := filepath.Join(home, ".pi", "agent", "models.json")
+	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+		return err
+	}
+
+	config := make(map[string]any)
+	if data, err := os.ReadFile(configPath); err == nil {
+		_ = json.Unmarshal(data, &config)
+	}
+
+	providers, ok := config["providers"].(map[string]any)
+	if !ok {
+		providers = make(map[string]any)
+	}
+
+	ollama, ok := providers["ollama"].(map[string]any)
+	if !ok {
+		ollama = map[string]any{
+			"baseUrl": envconfig.Host().String() + "/v1",
+			"api":     "openai-completions",
+			"apiKey":  "ollama",
+		}
+	}
+
+	existingModels, ok := ollama["models"].([]any)
+	if !ok {
+		existingModels = make([]any, 0)
+	}
+
+	// Build set of selected models to track which need to be added
+	selectedSet := make(map[string]bool, len(models))
+	for _, m := range models {
+		selectedSet[m] = true
+	}
+
+	// Build new models list:
+	// 1. Keep user-managed models (no _launch marker) - untouched
+	// 2. Keep ollama-managed models (_launch marker) that are still selected
+	// 3. Add new ollama-managed models
+	var newModels []any
+	for _, m := range existingModels {
+		if modelObj, ok := m.(map[string]any); ok {
+			if id, ok := modelObj["id"].(string); ok {
+				// User-managed model (no _launch marker) - always preserve
+				if !isPiOllamaModel(modelObj) {
+					newModels = append(newModels, m)
+				} else if selectedSet[id] {
+					// Ollama-managed and still selected - keep it
+					newModels = append(newModels, m)
+					selectedSet[id] = false
+				}
+			}
+		}
+	}
+
+	// Add newly selected models that weren't already in the list
+	client := api.NewClient(envconfig.Host(), http.DefaultClient)
+	ctx := context.Background()
+	for _, model := range models {
+		if selectedSet[model] {
+			newModels = append(newModels, createConfig(ctx, client, model))
+		}
+	}
+
+	ollama["models"] = newModels
+	providers["ollama"] = ollama
+	config["providers"] = providers
+
+	configData, err := json.MarshalIndent(config, "", "  ")
+	if err != nil {
+		return err
+	}
+	if err := writeWithBackup(configPath, configData); err != nil {
+		return err
+	}
+
+	// Update settings.json with default provider and model
+	settingsPath := filepath.Join(home, ".pi", "agent", "settings.json")
+	settings := make(map[string]any)
+	if data, err := os.ReadFile(settingsPath); err == nil {
+		_ = json.Unmarshal(data, &settings)
+	}
+
+	settings["defaultProvider"] = "ollama"
+	settings["defaultModel"] = models[0]
+
+	settingsData, err := json.MarshalIndent(settings, "", "  ")
+	if err != nil {
+		return err
+	}
+	return writeWithBackup(settingsPath, settingsData)
+}
+
+func (p *Pi) Models() []string {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return nil
+	}
+
+	configPath := filepath.Join(home, ".pi", "agent", "models.json")
+	config, err := readJSONFile(configPath)
+	if err != nil {
+		return nil
+	}
+
+	providers, _ := config["providers"].(map[string]any)
+	ollama, _ := providers["ollama"].(map[string]any)
+	models, _ := ollama["models"].([]any)
+
+	var result []string
+	for _, m := range models {
+		if modelObj, ok := m.(map[string]any); ok {
+			if id, ok := modelObj["id"].(string); ok {
+				result = append(result, id)
+			}
+		}
+	}
+	slices.Sort(result)
+	return result
+}
+
+// isPiOllamaModel reports whether a model config entry is managed by ollama launch
+func isPiOllamaModel(cfg map[string]any) bool {
+	if v, ok := cfg["_launch"].(bool); ok && v {
+		return true
+	}
+	return false
+}
+
+// createConfig builds Pi model config with capability detection
+func createConfig(ctx context.Context, client *api.Client, modelID string) map[string]any {
+	cfg := map[string]any{
+		"id":      modelID,
+		"_launch": true,
+	}
+
+	resp, err := client.Show(ctx, &api.ShowRequest{Model: modelID})
+	if err != nil {
+		return cfg
+	}
+
+	// Set input types based on vision capability
+	if slices.Contains(resp.Capabilities, model.CapabilityVision) {
+		cfg["input"] = []string{"text", "image"}
+	} else {
+		cfg["input"] = []string{"text"}
+	}
+
+	// Set reasoning based on thinking capability
+	if slices.Contains(resp.Capabilities, model.CapabilityThinking) {
+		cfg["reasoning"] = true
+	}
+
+	// Extract context window from ModelInfo
+	for key, val := range resp.ModelInfo {
+		if strings.HasSuffix(key, ".context_length") {
+			if ctxLen, ok := val.(float64); ok && ctxLen > 0 {
+				cfg["contextWindow"] = int(ctxLen)
+			}
+			break
+		}
+	}
+
+	return cfg
+}
@@ -1,17 +1,17 @@
-package launch
+package config

 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"os"
 	"path/filepath"
-	"runtime"
-	"strings"
 	"testing"

-	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/types/model"
 )

@@ -33,341 +33,6 @@ func TestPiIntegration(t *testing.T) {
 	})
 }

-func TestPiRun_InstallAndWebSearchLifecycle(t *testing.T) {
-	if runtime.GOOS == "windows" {
-		t.Skip("uses POSIX shell test binaries")
-	}
-
-	writeScript := func(t *testing.T, path, content string) {
-		t.Helper()
-		if err := os.WriteFile(path, []byte(content), 0o755); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	seedPiScript := func(t *testing.T, dir string) {
-		t.Helper()
-		piPath := filepath.Join(dir, "pi")
-		listPath := filepath.Join(dir, "pi-list.txt")
-		piScript := fmt.Sprintf(`#!/bin/sh
-echo "$@" >> %q
-if [ "$1" = "list" ]; then
-  if [ -f %q ]; then
-    /bin/cat %q
-  fi
-  exit 0
-fi
-if [ "$1" = "update" ] && [ "$PI_FAIL_UPDATE" = "1" ]; then
-  echo "update failed" >&2
-  exit 1
-fi
-if [ "$1" = "install" ] && [ "$PI_FAIL_INSTALL" = "1" ]; then
-  echo "install failed" >&2
-  exit 1
-fi
-exit 0
-`, filepath.Join(dir, "pi.log"), listPath, listPath)
-		writeScript(t, piPath, piScript)
-	}
-
-	seedNpmNoop := func(t *testing.T, dir string) {
-		t.Helper()
-		writeScript(t, filepath.Join(dir, "npm"), "#!/bin/sh\nexit 0\n")
-	}
-
-	withConfirm := func(t *testing.T, fn func(prompt string) (bool, error)) {
-		t.Helper()
-		oldConfirm := DefaultConfirmPrompt
-		DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
-			return fn(prompt)
-		}
-		t.Cleanup(func() { DefaultConfirmPrompt = oldConfirm })
-	}
-
-	setCloudStatus := func(t *testing.T, disabled bool) {
-		t.Helper()
-		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path == "/api/status" {
-				fmt.Fprintf(w, `{"cloud":{"disabled":%t,"source":"config"}}`, disabled)
-				return
-			}
-			http.NotFound(w, r)
-		}))
-		t.Cleanup(srv.Close)
-		t.Setenv("OLLAMA_HOST", srv.URL)
-	}
-
-	t.Run("pi missing + user accepts install", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n  npm:@ollama/pi-web-search\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-
-		npmScript := fmt.Sprintf(`#!/bin/sh
-echo "$@" >> %q
-if [ "$1" = "install" ] && [ "$2" = "-g" ] && [ "$3" = %q ]; then
-  /bin/cat > %q <<'EOS'
-#!/bin/sh
-echo "$@" >> %q
-if [ "$1" = "list" ]; then
-  if [ -f %q ]; then
-    /bin/cat %q
-  fi
-  exit 0
-fi
-exit 0
-EOS
-  /bin/chmod +x %q
-fi
-exit 0
-`, filepath.Join(tmpDir, "npm.log"), piNpmPackage+"@latest", filepath.Join(tmpDir, "pi"), filepath.Join(tmpDir, "pi.log"), filepath.Join(tmpDir, "pi-list.txt"), filepath.Join(tmpDir, "pi-list.txt"), filepath.Join(tmpDir, "pi"))
-		writeScript(t, filepath.Join(tmpDir, "npm"), npmScript)
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			if strings.Contains(prompt, "Pi is not installed.") {
-				return true, nil
-			}
-			return true, nil
-		})
-
-		p := &Pi{}
-		if err := p.Run("ignored", nil, []string{"--version"}); err != nil {
-			t.Fatalf("Run() error = %v", err)
-		}
-
-		npmCalls, err := os.ReadFile(filepath.Join(tmpDir, "npm.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !strings.Contains(string(npmCalls), "install -g "+piNpmPackage+"@latest") {
-			t.Fatalf("expected npm install call, got:\n%s", npmCalls)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		got := string(piCalls)
-		if !strings.Contains(got, "list\n") {
-			t.Fatalf("expected pi list call, got:\n%s", got)
-		}
-		if !strings.Contains(got, "update "+piWebSearchSource+"\n") {
-			t.Fatalf("expected pi update call, got:\n%s", got)
-		}
-		if !strings.Contains(got, "--version\n") {
-			t.Fatalf("expected final pi launch call, got:\n%s", got)
-		}
-	})
-
-	t.Run("pi missing + user declines install", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		writeScript(t, filepath.Join(tmpDir, "npm"), "#!/bin/sh\nexit 0\n")
-
-		withConfirm(t, func(prompt string) (bool, error) {
-			if strings.Contains(prompt, "Pi is not installed.") {
-				return false, nil
-			}
-			return true, nil
-		})
-
-		p := &Pi{}
-		err := p.Run("ignored", nil, nil)
-		if err == nil || !strings.Contains(err.Error(), "pi installation cancelled") {
-			t.Fatalf("expected install cancellation error, got %v", err)
-		}
-	})
-
-	t.Run("pi installed + web search missing auto-installs", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		seedPiScript(t, tmpDir)
-		seedNpmNoop(t, tmpDir)
-		withConfirm(t, func(prompt string) (bool, error) {
-			t.Fatalf("did not expect confirmation prompt, got %q", prompt)
-			return false, nil
-		})
-
-		p := &Pi{}
-		if err := p.Run("ignored", nil, []string{"session"}); err != nil {
-			t.Fatalf("Run() error = %v", err)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		got := string(piCalls)
-		if !strings.Contains(got, "list\n") {
-			t.Fatalf("expected pi list call, got:\n%s", got)
-		}
-		if !strings.Contains(got, "install "+piWebSearchSource+"\n") {
-			t.Fatalf("expected pi install call, got:\n%s", got)
-		}
-		if strings.Contains(got, "update "+piWebSearchSource+"\n") {
-			t.Fatalf("did not expect pi update call when package missing, got:\n%s", got)
-		}
-		if !strings.Contains(got, "session\n") {
-			t.Fatalf("expected final pi launch call, got:\n%s", got)
-		}
-	})
-
-	t.Run("pi installed + web search present updates every launch", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n  "+piWebSearchSource+"\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		seedPiScript(t, tmpDir)
-		seedNpmNoop(t, tmpDir)
-
-		p := &Pi{}
-		if err := p.Run("ignored", nil, []string{"doctor"}); err != nil {
-			t.Fatalf("Run() error = %v", err)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		got := string(piCalls)
-		if !strings.Contains(got, "update "+piWebSearchSource+"\n") {
-			t.Fatalf("expected pi update call, got:\n%s", got)
-		}
-	})
-
-	t.Run("web search update failure warns and continues", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		t.Setenv("PI_FAIL_UPDATE", "1")
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n  "+piWebSearchSource+"\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		seedPiScript(t, tmpDir)
-		seedNpmNoop(t, tmpDir)
-
-		p := &Pi{}
-		stderr := captureStderr(t, func() {
-			if err := p.Run("ignored", nil, []string{"session"}); err != nil {
-				t.Fatalf("Run() should continue after web search update failure, got %v", err)
-			}
-		})
-		if !strings.Contains(stderr, "Warning: could not update "+piWebSearchPkg) {
-			t.Fatalf("expected update warning, got:\n%s", stderr)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !strings.Contains(string(piCalls), "session\n") {
-			t.Fatalf("expected final pi launch call, got:\n%s", piCalls)
-		}
-	})
-
-	t.Run("web search install failure warns and continues", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		t.Setenv("PI_FAIL_INSTALL", "1")
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		seedPiScript(t, tmpDir)
-		seedNpmNoop(t, tmpDir)
-		withConfirm(t, func(prompt string) (bool, error) {
-			t.Fatalf("did not expect confirmation prompt, got %q", prompt)
-			return false, nil
-		})
-
-		p := &Pi{}
-		stderr := captureStderr(t, func() {
-			if err := p.Run("ignored", nil, []string{"session"}); err != nil {
-				t.Fatalf("Run() should continue after web search install failure, got %v", err)
-			}
-		})
-		if !strings.Contains(stderr, "Warning: could not install "+piWebSearchPkg) {
-			t.Fatalf("expected install warning, got:\n%s", stderr)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if !strings.Contains(string(piCalls), "session\n") {
-			t.Fatalf("expected final pi launch call, got:\n%s", piCalls)
-		}
-	})
-
-	t.Run("cloud disabled skips web search package management", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, true)
-		if err := os.WriteFile(filepath.Join(tmpDir, "pi-list.txt"), []byte("User packages:\n"), 0o644); err != nil {
-			t.Fatal(err)
-		}
-		seedPiScript(t, tmpDir)
-		seedNpmNoop(t, tmpDir)
-
-		p := &Pi{}
-		stderr := captureStderr(t, func() {
-			if err := p.Run("ignored", nil, []string{"session"}); err != nil {
-				t.Fatalf("Run() error = %v", err)
-			}
-		})
-		if !strings.Contains(stderr, "Cloud is disabled; skipping "+piWebSearchPkg+" setup.") {
-			t.Fatalf("expected cloud-disabled skip message, got:\n%s", stderr)
-		}
-
-		piCalls, err := os.ReadFile(filepath.Join(tmpDir, "pi.log"))
-		if err != nil {
-			t.Fatal(err)
-		}
-		got := string(piCalls)
-		if strings.Contains(got, "list\n") || strings.Contains(got, "install "+piWebSearchSource+"\n") || strings.Contains(got, "update "+piWebSearchSource+"\n") {
-			t.Fatalf("did not expect web search package management calls, got:\n%s", got)
-		}
-		if !strings.Contains(got, "session\n") {
-			t.Fatalf("expected final pi launch call, got:\n%s", got)
-		}
-	})
-
-	t.Run("missing npm returns error before pi flow", func(t *testing.T) {
-		tmpDir := t.TempDir()
-		setTestHome(t, tmpDir)
-		t.Setenv("PATH", tmpDir)
-		setCloudStatus(t, false)
-		seedPiScript(t, tmpDir)
-
-		p := &Pi{}
-		err := p.Run("ignored", nil, []string{"session"})
-		if err == nil || !strings.Contains(err.Error(), "npm (Node.js) is required to launch pi") {
-			t.Fatalf("expected missing npm error, got %v", err)
-		}
-
-		if _, statErr := os.Stat(filepath.Join(tmpDir, "pi.log")); !os.IsNotExist(statErr) {
-			t.Fatalf("expected pi not to run when npm is missing, stat err = %v", statErr)
-		}
-	})
-}
-
 func TestPiPaths(t *testing.T) {
 	pi := &Pi{}

@@ -432,7 +97,7 @@ func TestPiEdit(t *testing.T) {
 	}

 	t.Run("returns nil for empty models", func(t *testing.T) {
-		if err := pi.Edit(testLaunchModels()); err != nil {
+		if err := pi.Edit([]string{}); err != nil {
 			t.Errorf("Edit([]) error = %v, want nil", err)
 		}
 	})
@@ -441,7 +106,7 @@ func TestPiEdit(t *testing.T) {
 		cleanup()

 		models := []string{"llama3.2", "qwen3:8b"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -494,7 +159,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		models := []string{"new-model"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -527,48 +192,6 @@ func TestPiEdit(t *testing.T) {
 		}
 	})

-	t.Run("rebuilds stale existing managed cloud model", func(t *testing.T) {
-		cleanup()
-		os.MkdirAll(configDir, 0o755)
-
-		existingConfig := `{
-			"providers": {
-				"ollama": {
-					"baseUrl": "http://localhost:11434/v1",
-					"api": "openai-completions",
-					"apiKey": "ollama",
-					"models": [
-						{"id": "glm-5:cloud", "_launch": true, "legacyField": "stale"}
-					]
-				}
-			}
-		}`
-		if err := os.WriteFile(configPath, []byte(existingConfig), 0o644); err != nil {
-			t.Fatal(err)
-		}
-
-		if err := pi.Edit(testLaunchModels("glm-5:cloud")); err != nil {
-			t.Fatalf("Edit() error = %v", err)
-		}
-
-		cfg := readConfig()
-		providers := cfg["providers"].(map[string]any)
-		ollama := providers["ollama"].(map[string]any)
-		modelsArray := ollama["models"].([]any)
-		modelEntry := modelsArray[0].(map[string]any)
-
-		if modelEntry["contextWindow"] != float64(202_752) {
-			t.Errorf("contextWindow = %v, want 202752", modelEntry["contextWindow"])
-		}
-		input, ok := modelEntry["input"].([]any)
-		if !ok || len(input) != 1 || input[0] != "text" {
-			t.Errorf("input = %v, want [text]", modelEntry["input"])
-		}
-		if _, ok := modelEntry["legacyField"]; ok {
-			t.Error("legacyField should be removed when stale managed cloud entry is rebuilt")
-		}
-	})
-
 	t.Run("replaces old models with new ones", func(t *testing.T) {
 		cleanup()
 		os.MkdirAll(configDir, 0o755)
@@ -592,7 +215,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		newModels := []string{"new-model-1", "new-model-2"}
-		if err := pi.Edit(launchModelsFromNames(newModels)); err != nil {
+		if err := pi.Edit(newModels); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -643,7 +266,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		newModels := []string{"keep-model", "add-model"}
-		if err := pi.Edit(launchModelsFromNames(newModels)); err != nil {
+		if err := pi.Edit(newModels); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -680,7 +303,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		models := []string{"test-model"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() should not fail with corrupt config, got %v", err)
 		}

@@ -729,7 +352,7 @@ func TestPiEdit(t *testing.T) {

 		// Add a new ollama-managed model
 		newModels := []string{"new-ollama-model"}
-		if err := pi.Edit(launchModelsFromNames(newModels)); err != nil {
+		if err := pi.Edit(newModels); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -790,7 +413,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		models := []string{"llama3.2"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -828,7 +451,7 @@ func TestPiEdit(t *testing.T) {
 		os.MkdirAll(configDir, 0o755)

 		models := []string{"qwen3:8b"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() error = %v", err)
 		}

@@ -862,7 +485,7 @@ func TestPiEdit(t *testing.T) {
 		}

 		models := []string{"test-model"}
-		if err := pi.Edit(launchModelsFromNames(models)); err != nil {
+		if err := pi.Edit(models); err != nil {
 			t.Fatalf("Edit() should not fail with corrupt settings, got %v", err)
 		}

@@ -885,62 +508,6 @@ func TestPiEdit(t *testing.T) {
 	})
 }

-func TestPiEdit_CreatesDistinctBackupsForEachManagedFile(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.URL.Path == "/api/show" {
-			fmt.Fprint(w, `{"capabilities":[],"model_info":{}}`)
-			return
-		}
-		w.WriteHeader(http.StatusNotFound)
-	}))
-	defer srv.Close()
-	t.Setenv("OLLAMA_HOST", srv.URL)
-
-	pi := &Pi{}
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	configDir := filepath.Join(tmpDir, ".pi", "agent")
-	modelsPath := filepath.Join(configDir, "models.json")
-	settingsPath := filepath.Join(configDir, "settings.json")
-	backupDir := fileutil.BackupDir()
-
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	modelsOriginal := fmt.Sprintf(`{"marker":"models-%d","providers":{"ollama":{"models":[]}}}`, os.Getpid())
-	settingsOriginal := fmt.Sprintf(`{"marker":"settings-%d","defaultProvider":"other","defaultModel":"old"}`, os.Getpid())
-	if err := os.WriteFile(modelsPath, []byte(modelsOriginal), 0o644); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(settingsPath, []byte(settingsOriginal), 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	if err := pi.Edit(testLaunchModels("llama3.2")); err != nil {
-		t.Fatalf("Edit() error = %v", err)
-	}
-
-	assertBackupMatches := func(pattern, want string) {
-		t.Helper()
-		backups, err := filepath.Glob(filepath.Join(backupDir, pattern))
-		if err != nil {
-			t.Fatalf("glob %q failed: %v", pattern, err)
-		}
-		for _, backup := range backups {
-			data, err := os.ReadFile(backup)
-			if err == nil && string(data) == want {
-				return
-			}
-		}
-		t.Fatalf("backup matching %q with expected content not found", pattern)
-	}
-
-	assertBackupMatches(filepath.Join("pi", "models.json.*"), modelsOriginal)
-	assertBackupMatches(filepath.Join("pi", "settings.json.*"), settingsOriginal)
-}
-
 func TestPiModels(t *testing.T) {
 	pi := &Pi{}

@@ -1084,7 +651,19 @@ func TestIsPiOllamaModel(t *testing.T) {

 func TestCreateConfig(t *testing.T) {
 	t.Run("sets vision input when model has vision capability", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "llava:7b", Capabilities: []model.Capability{model.CapabilityVision}})
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":["vision"],"model_info":{}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "llava:7b")

 		if cfg["id"] != "llava:7b" {
 			t.Errorf("id = %v, want llava:7b", cfg["id"])
@@ -1099,7 +678,19 @@ func TestCreateConfig(t *testing.T) {
 	})

 	t.Run("sets text-only input when model lacks vision", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "llama3.2", Capabilities: []model.Capability{model.CapabilityCompletion}})
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":["completion"],"model_info":{}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "llama3.2")

 		input, ok := cfg["input"].([]string)
 		if !ok || len(input) != 1 || input[0] != "text" {
@@ -1111,15 +702,39 @@ func TestCreateConfig(t *testing.T) {
 	})

 	t.Run("sets reasoning when model has thinking capability", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "qwq", Capabilities: []model.Capability{model.CapabilityThinking}})
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":["thinking"],"model_info":{}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "qwq")

 		if cfg["reasoning"] != true {
 			t.Error("expected reasoning = true for thinking model")
 		}
 	})

-	t.Run("sets context window from metadata", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "llama3.2", ContextLength: 131072})
+	t.Run("extracts context window from model info", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":[],"model_info":{"llama.context_length":131072}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "llama3.2")

 		if cfg["contextWindow"] != 131072 {
 			t.Errorf("contextWindow = %v, want 131072", cfg["contextWindow"])
@@ -1127,11 +742,19 @@ func TestCreateConfig(t *testing.T) {
 	})

 	t.Run("handles all capabilities together", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{
-			Name:          "qwen3-vision",
-			Capabilities:  []model.Capability{model.CapabilityVision, model.CapabilityThinking},
-			ContextLength: 32768,
-		})
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":["vision","thinking"],"model_info":{"qwen3.context_length":32768}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "qwen3-vision")

 		input := cfg["input"].([]string)
 		if len(input) != 2 || input[0] != "text" || input[1] != "image" {
@@ -1145,8 +768,17 @@ func TestCreateConfig(t *testing.T) {
 		}
 	})

-	t.Run("returns minimal config when metadata is unavailable", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "missing-model"})
+	t.Run("returns minimal config when show fails", func(t *testing.T) {
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusNotFound)
+			fmt.Fprintf(w, `{"error":"model not found"}`)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "missing-model")

 		if cfg["id"] != "missing-model" {
 			t.Errorf("id = %v, want missing-model", cfg["id"])
@@ -1154,44 +786,32 @@ func TestCreateConfig(t *testing.T) {
 		if cfg["_launch"] != true {
 			t.Error("expected _launch = true")
 		}
-		// Input defaults to text even when capabilities are unavailable.
-		input, ok := cfg["input"].([]string)
-		if !ok || len(input) != 1 || input[0] != "text" {
-			t.Errorf("input = %v, want [text]", cfg["input"])
+		// Should not have capability fields
+		if _, ok := cfg["input"]; ok {
+			t.Error("input should not be set when show fails")
 		}
 		if _, ok := cfg["reasoning"]; ok {
-			t.Error("reasoning should not be set when metadata is unavailable")
+			t.Error("reasoning should not be set when show fails")
 		}
 		if _, ok := cfg["contextWindow"]; ok {
-			t.Error("contextWindow should not be set when metadata is unavailable")
+			t.Error("contextWindow should not be set when show fails")
 		}
 	})

-	t.Run("cloud model falls back to hardcoded context", func(t *testing.T) {
-		cfg := createConfig(fallbackLaunchModel("kimi-k2.5:cloud"))
-
-		if cfg["contextWindow"] != 262_144 {
-			t.Errorf("contextWindow = %v, want 262144", cfg["contextWindow"])
-		}
-	})
-
-	t.Run("cloud model uses hardcoded context when tags omit context", func(t *testing.T) {
-		cfg := createConfig(fallbackLaunchModel("glm-5:cloud"))
-
-		if cfg["contextWindow"] != 202_752 {
-			t.Errorf("contextWindow = %v, want 202752", cfg["contextWindow"])
-		}
-	})
-
-	t.Run("cloud model with dash suffix falls back to hardcoded context", func(t *testing.T) {
-		cfg := createConfig(fallbackLaunchModel("gpt-oss:120b-cloud"))
-
-		if cfg["contextWindow"] != 131_072 {
-			t.Errorf("contextWindow = %v, want 131072", cfg["contextWindow"])
-		}
-	})
 	t.Run("skips zero context length", func(t *testing.T) {
-		cfg := createConfig(LaunchModel{Name: "test-model", ContextLength: 0})
+		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/api/show" {
+				fmt.Fprintf(w, `{"capabilities":[],"model_info":{"llama.context_length":0}}`)
+				return
+			}
+			w.WriteHeader(http.StatusNotFound)
+		}))
+		defer srv.Close()
+
+		u, _ := url.Parse(srv.URL)
+		client := api.NewClient(u, srv.Client())
+
+		cfg := createConfig(context.Background(), client, "test-model")

 		if _, ok := cfg["contextWindow"]; ok {
 			t.Error("contextWindow should not be set for zero value")
@@ -0,0 +1,59 @@
+package config
+
+import (
+	"errors"
+	"fmt"
+	"os"
+
+	"golang.org/x/term"
+)
+
+// ANSI escape sequences for terminal formatting.
+const (
+	ansiBold   = "\033[1m"
+	ansiReset  = "\033[0m"
+	ansiGray   = "\033[37m"
+	ansiGreen  = "\033[32m"
+	ansiYellow = "\033[33m"
+)
+
+// ErrCancelled is returned when the user cancels a selection.
+var ErrCancelled = errors.New("cancelled")
+
+// errCancelled is kept as an alias for backward compatibility within the package.
+var errCancelled = ErrCancelled
+
+// DefaultConfirmPrompt provides a TUI-based confirmation prompt.
+// When set, confirmPrompt delegates to it instead of using raw terminal I/O.
+var DefaultConfirmPrompt func(prompt string) (bool, error)
+
+func confirmPrompt(prompt string) (bool, error) {
+	if DefaultConfirmPrompt != nil {
+		return DefaultConfirmPrompt(prompt)
+	}
+
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return false, err
+	}
+	defer term.Restore(fd, oldState)
+
+	fmt.Fprintf(os.Stderr, "%s (\033[1my\033[0m/n) ", prompt)
+
+	buf := make([]byte, 1)
+	for {
+		if _, err := os.Stdin.Read(buf); err != nil {
+			return false, err
+		}
+
+		switch buf[0] {
+		case 'Y', 'y', 13:
+			fmt.Fprintf(os.Stderr, "yes\r\n")
+			return true, nil
+		case 'N', 'n', 27, 3:
+			fmt.Fprintf(os.Stderr, "no\r\n")
+			return false, nil
+		}
+	}
+}
@@ -0,0 +1,19 @@
+package config
+
+import (
+	"testing"
+)
+
+func TestErrCancelled(t *testing.T) {
+	t.Run("NotNil", func(t *testing.T) {
+		if errCancelled == nil {
+			t.Error("errCancelled should not be nil")
+		}
+	})
+
+	t.Run("Message", func(t *testing.T) {
+		if errCancelled.Error() != "cancelled" {
+			t.Errorf("expected 'cancelled', got %q", errCancelled.Error())
+		}
+	})
+}
				`@@ -1 +0,0 @@`
				`<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg"><title>Claude Code</title><path clip-rule="evenodd" d="M20.998 10.949H24v3.102h-3v3.028h-1.487V20H18v-2.921h-1.487V20H15v-2.921H9V20H7.488v-2.921H6V20H4.487v-2.921H3V14.05H0V10.95h3V5h17.998v5.949zM6 10.949h1.488V8.102H6v2.847zm10.51 0H18V8.102h-1.49v2.847z" fill="#D97757" fill-rule="evenodd"></path></svg>`
				`@@ -1 +0,0 @@`
				<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 320 320"><path fill="#fff" d="m297.06 130.97c7.26-21.79 4.76-45.66-6.85-65.48-17.46-30.4-52.56-46.04-86.84-38.68-15.25-17.18-37.16-26.95-60.13-26.81-35.04-.08-66.13 22.48-76.91 55.82-22.51 4.61-41.94 18.7-53.31 38.67-17.59 30.32-13.58 68.54 9.92 94.54-7.26 21.79-4.76 45.66 6.85 65.48 17.46 30.4 52.56 46.04 86.84 38.68 15.24 17.18 37.16 26.95 60.13 26.8 35.06.09 66.16-22.49 76.94-55.86 22.51-4.61 41.94-18.7 53.31-38.67 17.57-30.32 13.55-68.51-9.94-94.51zm-120.28 168.11c-14.03.02-27.62-4.89-38.39-13.88.49-.26 1.34-.73 1.89-1.07l63.72-36.8c3.26-1.85 5.26-5.32 5.24-9.07v-89.83l26.93 15.55c.29.14.48.42.52.74v74.39c-.04 33.08-26.83 59.9-59.91 59.97zm-128.84-55.03c-7.03-12.14-9.56-26.37-7.15-40.18.47.28 1.3.79 1.89 1.13l63.72 36.8c3.23 1.89 7.23 1.89 10.47 0l77.79-44.92v31.1c.02.32-.13.63-.38.83l-64.41 37.19c-28.69 16.52-65.33 6.7-81.92-21.95zm-16.77-139.09c7-12.16 18.05-21.46 31.21-26.29 0 .55-.03 1.52-.03 2.2v73.61c-.02 3.74 1.98 7.21 5.23 9.06l77.79 44.91-26.93 15.55c-.27.18-.61.21-.91.08l-64.42-37.22c-28.63-16.58-38.45-53.21-21.95-81.89zm221.26 51.49-77.79-44.92 26.93-15.54c.27-.18.61-.21.91-.08l64.42 37.19c28.68 16.57 38.51 53.26 21.94 81.94-7.01 12.14-18.05 21.44-31.2 26.28v-75.81c.03-3.74-1.96-7.2-5.2-9.06zm26.8-40.34c-.47-.29-1.3-.79-1.89-1.13l-63.72-36.8c-3.23-1.89-7.23-1.89-10.47 0l-77.79 44.92v-31.1c-.02-.32.13-.63.38-.83l64.41-37.16c28.69-16.55 65.37-6.7 81.91 22 6.99 12.12 9.52 26.31 7.15 40.1zm-168.51 55.43-26.94-15.55c-.29-.14-.48-.42-.52-.74v-74.39c.02-33.12 26.89-59.96 60.01-59.94 14.01 0 27.57 4.92 38.34 13.88-.49.26-1.33.73-1.89 1.07l-63.72 36.8c-3.26 1.85-5.26 5.31-5.24 9.06l-.04 89.79zm14.63-31.54 34.65-20.01 34.65 20v40.01l-34.65 20-34.65-20z"/></svg>