handle edge case when a blob has been uploaded earlier

2026-02-13 09:05:34 -05:00 · 2026-02-11 09:34:00 -08:00
79 changed files with 2934 additions and 5246 deletions
--- a/README.md
+++ b/README.md
@@ -1,30 +1,20 @@
-<p align="center">
-  <a href="https://ollama.com">
-    <img src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7" alt="ollama" width="200"/>
+<div align="center">
+  <a href="https://ollama.com">
+    <img alt="ollama" width="240" src="https://github.com/ollama/ollama/assets/3325447/0d0b44e2-8f4a-4e99-9b52-a5c1c741c8f7">
  </a>
-</p>
+</div>

 # Ollama

-Start building with open models.
-
-## Download
+Get up and running with large language models.

 ### macOS

-```shell
-curl -fsSL https://ollama.com/install.sh | sh
-```
-
-or [download manually](http://localhost:8080/download/Ollama.dmg)
+[Download](https://ollama.com/download/Ollama.dmg)

 ### Windows

-```shell
-irm https://ollama.com/install.ps1 | iex
-```
-
-or [download manually](https://ollama.com/download/OllamaSetup.exe)
+[Download](https://ollama.com/download/OllamaSetup.exe)

 ### Linux

@@ -46,311 +36,649 @@ The official [Ollama Docker image](https://hub.docker.com/r/ollama/ollama) `olla
 ### Community

 - [Discord](https://discord.gg/ollama)
- [𝕏 (Twitter)](https://x.com/ollama)
 - [Reddit](https://reddit.com/r/ollama)

-## Get started
+## Quickstart

-```
-ollama
-```
+To run and chat with [Gemma 3](https://ollama.com/library/gemma3):

-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
-
-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), [Droid](https://docs.ollama.com/integrations/droid), and [OpenCode](https://docs.ollama.com/integrations/opencode).
-
-### AI assistant
-
-Use [OpenClaw](https://docs.ollama.com/integrations/openclaw) to turn Ollama into a personal AI assistant across WhatsApp, Telegram, Slack, Discord, and more:
-
-```
-ollama launch openclaw
-```
-
-### Chat with a model
-
-Run and chat with [Gemma 3](https://ollama.com/library/gemma3):
-
-```
+```shell
 ollama run gemma3
 ```

-See [ollama.com/library](https://ollama.com/library) for the full list.
+## Model library

-See the [quickstart guide](https://docs.ollama.com/quickstart) for more details.
+Ollama supports a list of models available on [ollama.com/library](https://ollama.com/library "ollama model library")
+
+Here are some example models that can be downloaded:
+
+| Model              | Parameters | Size  | Download                         |
+| ------------------ | ---------- | ----- | -------------------------------- |
+| Gemma 3            | 1B         | 815MB | `ollama run gemma3:1b`           |
+| Gemma 3            | 4B         | 3.3GB | `ollama run gemma3`              |
+| Gemma 3            | 12B        | 8.1GB | `ollama run gemma3:12b`          |
+| Gemma 3            | 27B        | 17GB  | `ollama run gemma3:27b`          |
+| QwQ                | 32B        | 20GB  | `ollama run qwq`                 |
+| DeepSeek-R1        | 7B         | 4.7GB | `ollama run deepseek-r1`         |
+| DeepSeek-R1        | 671B       | 404GB | `ollama run deepseek-r1:671b`    |
+| Llama 4            | 109B       | 67GB  | `ollama run llama4:scout`        |
+| Llama 4            | 400B       | 245GB | `ollama run llama4:maverick`     |
+| Llama 3.3          | 70B        | 43GB  | `ollama run llama3.3`            |
+| Llama 3.2          | 3B         | 2.0GB | `ollama run llama3.2`            |
+| Llama 3.2          | 1B         | 1.3GB | `ollama run llama3.2:1b`         |
+| Llama 3.2 Vision   | 11B        | 7.9GB | `ollama run llama3.2-vision`     |
+| Llama 3.2 Vision   | 90B        | 55GB  | `ollama run llama3.2-vision:90b` |
+| Llama 3.1          | 8B         | 4.7GB | `ollama run llama3.1`            |
+| Llama 3.1          | 405B       | 231GB | `ollama run llama3.1:405b`       |
+| Phi 4              | 14B        | 9.1GB | `ollama run phi4`                |
+| Phi 4 Mini         | 3.8B       | 2.5GB | `ollama run phi4-mini`           |
+| Mistral            | 7B         | 4.1GB | `ollama run mistral`             |
+| Moondream 2        | 1.4B       | 829MB | `ollama run moondream`           |
+| Neural Chat        | 7B         | 4.1GB | `ollama run neural-chat`         |
+| Starling           | 7B         | 4.1GB | `ollama run starling-lm`         |
+| Code Llama         | 7B         | 3.8GB | `ollama run codellama`           |
+| Llama 2 Uncensored | 7B         | 3.8GB | `ollama run llama2-uncensored`   |
+| LLaVA              | 7B         | 4.5GB | `ollama run llava`               |
+| Granite-3.3        | 8B         | 4.9GB | `ollama run granite3.3`          |
+
+> [!NOTE]
+> You should have at least 8 GB of RAM available to run the 7B models, 16 GB to run the 13B models, and 32 GB to run the 33B models.
+
+## Customize a model
+
+### Import from GGUF
+
+Ollama supports importing GGUF models in the Modelfile:
+
+1. Create a file named `Modelfile`, with a `FROM` instruction with the local filepath to the model you want to import.
+
+   ```
+   FROM ./vicuna-33b.Q4_0.gguf
+   ```
+
+2. Create the model in Ollama
+
+   ```shell
+   ollama create example -f Modelfile
+   ```
+
+3. Run the model
+
+   ```shell
+   ollama run example
+   ```
+
+### Import from Safetensors
+
+See the [guide](https://docs.ollama.com/import) on importing models for more information.
+
+### Customize a prompt
+
+Models from the Ollama library can be customized with a prompt. For example, to customize the `llama3.2` model:
+
+```shell
+ollama pull llama3.2
+```
+
+Create a `Modelfile`:
+
+```
+FROM llama3.2
+
+# set the temperature to 1 [higher is more creative, lower is more coherent]
+PARAMETER temperature 1
+
+# set the system message
+SYSTEM """
+You are Mario from Super Mario Bros. Answer as Mario, the assistant, only.
+"""
+```
+
+Next, create and run the model:
+
+```
+ollama create mario -f ./Modelfile
+ollama run mario
+>>> hi
+Hello! It's your friend Mario.
+```
+
+For more information on working with a Modelfile, see the [Modelfile](https://docs.ollama.com/modelfile) documentation.
+
+## CLI Reference
+
+### Create a model
+
+`ollama create` is used to create a model from a Modelfile.
+
+```shell
+ollama create mymodel -f ./Modelfile
+```
+
+### Pull a model
+
+```shell
+ollama pull llama3.2
+```
+
+> This command can also be used to update a local model. Only the diff will be pulled.
+
+### Remove a model
+
+```shell
+ollama rm llama3.2
+```
+
+### Copy a model
+
+```shell
+ollama cp llama3.2 my-model
+```
+
+### Multiline input
+
+For multiline input, you can wrap text with `"""`:
+
+```
+>>> """Hello,
+... world!
+... """
+I'm a basic program that prints the famous "Hello, world!" message to the console.
+```
+
+### Multimodal models
+
+```
+ollama run llava "What's in this image? /Users/jmorgan/Desktop/smile.png"
+```
+
+> **Output**: The image features a yellow smiley face, which is likely the central focus of the picture.
+
+### Pass the prompt as an argument
+
+```shell
+ollama run llama3.2 "Summarize this file: $(cat README.md)"
+```
+
+> **Output**: Ollama is a lightweight, extensible framework for building and running language models on the local machine. It provides a simple API for creating, running, and managing models, as well as a library of pre-built models that can be easily used in a variety of applications.
+
+### Show model information
+
+```shell
+ollama show llama3.2
+```
+
+### List models on your computer
+
+```shell
+ollama list
+```
+
+### List which models are currently loaded
+
+```shell
+ollama ps
+```
+
+### Stop a model which is currently running
+
+```shell
+ollama stop llama3.2
+```
+
+### Generate embeddings from the CLI
+
+```shell
+ollama run embeddinggemma "Your text to embed"
+```
+
+You can also pipe text for scripted workflows:
+
+```shell
+echo "Your text to embed" | ollama run embeddinggemma
+```
+
+### Start Ollama
+
+`ollama serve` is used when you want to start ollama without running the desktop application.
+
+## Building
+
+See the [developer guide](https://github.com/ollama/ollama/blob/main/docs/development.md)
+
+### Running local builds
+
+Next, start the server:
+
+```shell
+./ollama serve
+```
+
+Finally, in a separate shell, run a model:
+
+```shell
+./ollama run llama3.2
+```
+
+## Building with MLX (experimental)
+
+First build the MLX libraries:
+
+```shell
+cmake --preset MLX
+cmake --build --preset MLX --parallel
+cmake --install build --component MLX
+```
+
+When building with the `-tags mlx` flag, the main `ollama` binary includes MLX support for experimental features like image generation:
+
+```shell
+go build -tags mlx .
+```
+
+Finally, start the server:
+
+```
+./ollama serve
+```
+
+### Building MLX with CUDA
+
+When building with CUDA, use the preset "MLX CUDA 13" or "MLX CUDA 12" to enable CUDA with default architectures:
+
+```shell
+cmake --preset 'MLX CUDA 13'
+cmake --build --preset 'MLX CUDA 13' --parallel
+cmake --install build --component MLX
+```

 ## REST API

 Ollama has a REST API for running and managing models.

-```
-curl http://localhost:11434/api/chat -d '{
-  "model": "gemma3",
-  "messages": [{
-    "role": "user",
-    "content": "Why is the sky blue?"
-  }],
-  "stream": false
+### Generate a response
+
+```shell
+curl http://localhost:11434/api/generate -d '{
+  "model": "llama3.2",
+  "prompt":"Why is the sky blue?"
 }'
 ```

-See the [API documentation](https://docs.ollama.com/api) for all endpoints.
+### Chat with a model

-### Python
-
-```
-pip install ollama
+```shell
+curl http://localhost:11434/api/chat -d '{
+  "model": "llama3.2",
+  "messages": [
+    { "role": "user", "content": "why is the sky blue?" }
+  ]
+}'
 ```

-```python
-from ollama import chat
-
-response = chat(model='gemma3', messages=[
-  {
-    'role': 'user',
-    'content': 'Why is the sky blue?',
-  },
-])
-print(response.message.content)
-```
-
-### JavaScript
-
-```
-npm i ollama
-```
-
-```javascript
-import ollama from "ollama";
-
-const response = await ollama.chat({
-  model: "gemma3",
-  messages: [{ role: "user", content: "Why is the sky blue?" }],
-});
-console.log(response.message.content);
-```
-
-## Supported backends
-
- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
-
-## Documentation
-
- [CLI reference](https://docs.ollama.com/cli)
- [REST API reference](https://docs.ollama.com/api)
- [Importing models](https://docs.ollama.com/import)
- [Modelfile reference](https://docs.ollama.com/modelfile)
- [Building from source](https://github.com/ollama/ollama/blob/main/docs/development.md)
+See the [API documentation](./docs/api.md) for all endpoints.

 ## Community Integrations

-> Want to add your project? Open a pull request.
+### Web & Desktop

-### Chat Interfaces
+- [Onyx](https://github.com/onyx-dot-app/onyx)
+- [Open WebUI](https://github.com/open-webui/open-webui)
+- [SwiftChat (macOS with ReactNative)](https://github.com/aws-samples/swift-chat)
+- [Enchanted (macOS native)](https://github.com/AugustDev/enchanted)
+- [Hollama](https://github.com/fmaclen/hollama)
+- [Lollms WebUI (Single user)](https://github.com/ParisNeo/lollms-webui)
+- [Lollms (Multi users)](https://github.com/ParisNeo/lollms)
+- [LibreChat](https://github.com/danny-avila/LibreChat)
+- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt)
+- [HTML UI](https://github.com/rtcfirefly/ollama-ui)
+- [AI-UI](https://github.com/bajahaw/ai-ui)
+- [Saddle](https://github.com/jikkuatwork/saddle)
+- [TagSpaces](https://www.tagspaces.org) (A platform for file-based apps, [utilizing Ollama](https://docs.tagspaces.org/ai/) for the generation of tags and descriptions)
+- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama)
+- [Chatbot UI v2](https://github.com/mckaywrigley/chatbot-ui)
+- [Typescript UI](https://github.com/ollama-interface/Ollama-Gui?tab=readme-ov-file)
+- [Minimalistic React UI for Ollama Models](https://github.com/richawo/minimal-llm-ui)
+- [Ollamac](https://github.com/kevinhermawan/Ollamac)
+- [big-AGI](https://github.com/enricoros/big-AGI)
+- [Cheshire Cat assistant framework](https://github.com/cheshire-cat-ai/core)
+- [Amica](https://github.com/semperai/amica)
+- [chatd](https://github.com/BruceMacD/chatd)
+- [Ollama-SwiftUI](https://github.com/kghandour/Ollama-SwiftUI)
+- [Dify.AI](https://github.com/langgenius/dify)
+- [MindMac](https://mindmac.app)
+- [NextJS Web Interface for Ollama](https://github.com/jakobhoeg/nextjs-ollama-llm-ui)
+- [Msty](https://msty.app)
+- [Chatbox](https://github.com/Bin-Huang/Chatbox)
+- [WinForm Ollama Copilot](https://github.com/tgraupmann/WinForm_Ollama_Copilot)
+- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) with [Get Started Doc](https://docs.nextchat.dev/models/ollama)
+- [Alpaca WebUI](https://github.com/mmo80/alpaca-webui)
+- [OllamaGUI](https://github.com/enoch1118/ollamaGUI)
+- [OpenAOE](https://github.com/InternLM/OpenAOE)
+- [Odin Runes](https://github.com/leonid20000/OdinRunes)
+- [LLM-X](https://github.com/mrdjohnson/llm-x) (Progressive Web App)
+- [AnythingLLM (Docker + MacOs/Windows/Linux native app)](https://github.com/Mintplex-Labs/anything-llm)
+- [Screenpipe](https://github.com/mediar-ai/screenpipe) (24/7 screen & mic recording with AI-powered search, uses Ollama for local LLM features)
+- [Ollama Basic Chat: Uses HyperDiv Reactive UI](https://github.com/rapidarchitect/ollama_basic_chat)
+- [Ollama-chats RPG](https://github.com/drazdra/ollama-chats)
+- [IntelliBar](https://intellibar.app/) (AI-powered assistant for macOS)
+- [Jirapt](https://github.com/AliAhmedNada/jirapt) (Jira Integration to generate issues, tasks, epics)
+- [ojira](https://github.com/AliAhmedNada/ojira) (Jira chrome plugin to easily generate descriptions for tasks)
+- [QA-Pilot](https://github.com/reid41/QA-Pilot) (Interactive chat tool that can leverage Ollama models for rapid understanding and navigation of GitHub code repositories)
+- [ChatOllama](https://github.com/sugarforever/chat-ollama) (Open Source Chatbot based on Ollama with Knowledge Bases)
+- [CRAG Ollama Chat](https://github.com/Nagi-ovo/CRAG-Ollama-Chat) (Simple Web Search with Corrective RAG)
+- [RAGFlow](https://github.com/infiniflow/ragflow) (Open-source Retrieval-Augmented Generation engine based on deep document understanding)
+- [StreamDeploy](https://github.com/StreamDeploy-DevRel/streamdeploy-llm-app-scaffold) (LLM Application Scaffold)
+- [chat](https://github.com/swuecho/chat) (chat web app for teams)
+- [Lobe Chat](https://github.com/lobehub/lobe-chat) with [Integrating Doc](https://lobehub.com/docs/self-hosting/examples/ollama)
+- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) (Local Chat with multiple PDFs using Ollama and RAG)
+- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) (Flexible native client with RAG & multi-agent automation)
+- [macai](https://github.com/Renset/macai) (macOS client for Ollama, ChatGPT, and other compatible API back-ends)
+- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) (RWKV offline LLM deployment tool, also usable as a client for ChatGPT and Ollama)
+- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) (app to evaluate and compare models)
+- [Olpaka](https://github.com/Otacon/olpaka) (User-friendly Flutter Web App for Ollama)
+- [Casibase](https://casibase.org) (An open source AI knowledge base and dialogue system combining the latest RAG, SSO, ollama support, and multiple large language models.)
+- [OllamaSpring](https://github.com/CrazyNeil/OllamaSpring) (Ollama Client for macOS)
+- [LLocal.in](https://github.com/kartikm7/llocal) (Easy to use Electron Desktop Client for Ollama)
+- [Shinkai Desktop](https://github.com/dcSpark/shinkai-apps) (Two click install Local AI using Ollama + Files + RAG)
+- [AiLama](https://github.com/zeyoyt/ailama) (A Discord User App that allows you to interact with Ollama anywhere in Discord)
+- [Ollama with Google Mesop](https://github.com/rapidarchitect/ollama_mesop/) (Mesop Chat Client implementation with Ollama)
+- [R2R](https://github.com/SciPhi-AI/R2R) (Open-source RAG engine)
+- [Ollama-Kis](https://github.com/elearningshow/ollama-kis) (A simple easy-to-use GUI with sample custom LLM for Drivers Education)
+- [OpenGPA](https://opengpa.org) (Open-source offline-first Enterprise Agentic Application)
+- [Painting Droid](https://github.com/mateuszmigas/painting-droid) (Painting app with AI integrations)
+- [Kerlig AI](https://www.kerlig.com/) (AI writing assistant for macOS)
+- [AI Studio](https://github.com/MindWorkAI/AI-Studio)
+- [Sidellama](https://github.com/gyopak/sidellama) (browser-based LLM client)
+- [LLMStack](https://github.com/trypromptly/LLMStack) (No-code multi-agent framework to build LLM agents and workflows)
+- [BoltAI for Mac](https://boltai.com) (AI Chat Client for Mac)
+- [Harbor](https://github.com/av/harbor) (Containerized LLM Toolkit with Ollama as default backend)
+- [PyGPT](https://github.com/szczyglis-dev/py-gpt) (AI desktop assistant for Linux, Windows, and Mac)
+- [Alpaca](https://github.com/Jeffser/Alpaca) (An Ollama client application for Linux and macOS made with GTK4 and Adwaita)
+- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) (AutoGPT Ollama integration)
+- [Go-CREW](https://www.jonathanhecl.com/go-crew/) (Powerful Offline RAG in Golang)
+- [PartCAD](https://github.com/openvmp/partcad/) (CAD model generation with OpenSCAD and CadQuery)
+- [Ollama4j Web UI](https://github.com/ollama4j/ollama4j-web-ui) - Java-based Web UI for Ollama built with Vaadin, Spring Boot, and Ollama4j
+- [PyOllaMx](https://github.com/kspviswa/pyOllaMx) - macOS application capable of chatting with both Ollama and Apple MLX models.
+- [Cline](https://github.com/cline/cline) - Formerly known as Claude Dev is a VS Code extension for multi-file/whole-repo coding
+- [Void](https://github.com/voideditor/void) (Open source AI code editor and Cursor alternative)
+- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) (Desktop client with Ollama support)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Archyve](https://github.com/nickthecook/archyve) (RAG-enabling document library)
+- [crewAI with Mesop](https://github.com/rapidarchitect/ollama-crew-mesop) (Mesop Web Interface to run crewAI with Ollama)
+- [Tkinter-based client](https://github.com/chyok/ollama-gui) (Python tkinter-based Client for Ollama)
+- [LLMChat](https://github.com/trendy-design/llmchat) (Privacy focused, 100% local, intuitive all-in-one chat interface)
+- [Local Multimodal AI Chat](https://github.com/Leon-Sander/Local-Multimodal-AI-Chat) (Ollama-based LLM Chat with support for multiple features, including PDF RAG, voice chat, image-based interactions, and integration with OpenAI.)
+- [ARGO](https://github.com/xark-argo/argo) (Locally download and run Ollama and Huggingface models with RAG and deep research on Mac/Windows/Linux)
+- [OrionChat](https://github.com/EliasPereirah/OrionChat) - OrionChat is a web interface for chatting with different AI providers
+- [G1](https://github.com/bklieger-groq/g1) (Prototype of using prompting strategies to improve the LLM's reasoning through o1-like reasoning chains.)
+- [Web management](https://github.com/lemonit-eric-mao/ollama-web-management) (Web management page)
+- [Promptery](https://github.com/promptery/promptery) (desktop client for Ollama.)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [chat-ollama](https://github.com/annilq/chat-ollama) (a React Native client for Ollama)
+- [SpaceLlama](https://github.com/tcsenpai/spacellama) (Firefox and Chrome extension to quickly summarize web pages with ollama in a sidebar)
+- [YouLama](https://github.com/tcsenpai/youlama) (Webapp to quickly summarize any YouTube video, supporting Invidious as well)
+- [DualMind](https://github.com/tcsenpai/dualmind) (Experimental app allowing two models to talk to each other in the terminal or in a web interface)
+- [ollamarama-matrix](https://github.com/h1ddenpr0cess20/ollamarama-matrix) (Ollama chatbot for the Matrix chat protocol)
+- [ollama-chat-app](https://github.com/anan1213095357/ollama-chat-app) (Flutter-based chat app)
+- [Perfect Memory AI](https://www.perfectmemory.ai/) (Productivity AI assists personalized by what you have seen on your screen, heard, and said in the meetings)
+- [Hexabot](https://github.com/hexastack/hexabot) (A conversational AI builder)
+- [Reddit Rate](https://github.com/rapidarchitect/reddit_analyzer) (Search and Rate Reddit topics with a weighted summation)
+- [OpenTalkGpt](https://github.com/adarshM84/OpenTalkGpt) (Chrome Extension to manage open-source models supported by Ollama, create custom models, and chat with models from a user-friendly UI)
+- [VT](https://github.com/vinhnx/vt.ai) (A minimal multimodal AI chat app, with dynamic conversation routing. Supports local models via Ollama)
+- [Nosia](https://github.com/nosia-ai/nosia) (Easy to install and use RAG platform based on Ollama)
+- [Witsy](https://github.com/nbonamy/witsy) (An AI Desktop application available for Mac/Windows/Linux)
+- [Abbey](https://github.com/US-Artificial-Intelligence/abbey) (A configurable AI interface server with notebooks, document storage, and YouTube support)
+- [Minima](https://github.com/dmayboroda/minima) (RAG with on-premises or fully local workflow)
+- [aidful-ollama-model-delete](https://github.com/AidfulAI/aidful-ollama-model-delete) (User interface for simplified model cleanup)
+- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) (An AI-powered search engine & an open-source alternative to Perplexity AI)
+- [Ollama Chat WebUI for Docker ](https://github.com/oslook/ollama-webui) (Support for local docker deployment, lightweight ollama webui)
+- [AI Toolkit for Visual Studio Code](https://aka.ms/ai-tooklit/ollama-docs) (Microsoft-official VS Code extension to chat, test, evaluate models with Ollama support, and use them in your AI applications.)
+- [MinimalNextOllamaChat](https://github.com/anilkay/MinimalNextOllamaChat) (Minimal Web UI for Chat and Model Control)
+- [Chipper](https://github.com/TilmanGriesel/chipper) AI interface for tinkerers (Ollama, Haystack RAG, Python)
+- [ChibiChat](https://github.com/CosmicEventHorizon/ChibiChat) (Kotlin-based Android app to chat with Ollama and Koboldcpp API endpoints)
+- [LocalLLM](https://github.com/qusaismael/localllm) (Minimal Web-App to run ollama models on it with a GUI)
+- [Ollamazing](https://github.com/buiducnhat/ollamazing) (Web extension to run Ollama models)
+- [OpenDeepResearcher-via-searxng](https://github.com/benhaotang/OpenDeepResearcher-via-searxng) (A Deep Research equivalent endpoint with Ollama support for running locally)
+- [AntSK](https://github.com/AIDotNet/AntSK) (Out-of-the-box & Adaptable RAG Chatbot)
+- [MaxKB](https://github.com/1Panel-dev/MaxKB/) (Ready-to-use & flexible RAG Chatbot)
+- [yla](https://github.com/danielekp/yla) (Web interface to freely interact with your customized models)
+- [LangBot](https://github.com/RockChinQ/LangBot) (LLM-based instant messaging bots platform, with Agents, RAG features, supports multiple platforms)
+- [1Panel](https://github.com/1Panel-dev/1Panel/) (Web-based Linux Server Management Tool)
+- [AstrBot](https://github.com/Soulter/AstrBot/) (User-friendly LLM-based multi-platform chatbot with a WebUI, supporting RAG, LLM agents, and plugins integration)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+- [Flufy](https://github.com/Aharon-Bensadoun/Flufy) (A beautiful chat interface for interacting with Ollama's API. Built with React, TypeScript, and Material-UI.)
+- [Ellama](https://github.com/zeozeozeo/ellama) (Friendly native app to chat with an Ollama instance)
+- [screenpipe](https://github.com/mediar-ai/screenpipe) Build agents powered by your screen history
+- [Ollamb](https://github.com/hengkysteen/ollamb) (Simple yet rich in features, cross-platform built with Flutter and designed for Ollama. Try the [web demo](https://hengkysteen.github.io/demo/ollamb/).)
+- [Writeopia](https://github.com/Writeopia/Writeopia) (Text editor with integration with Ollama)
+- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) (AI collaborative workspace with Ollama, cross-platform and self-hostable)
+- [Lumina](https://github.com/cushydigit/lumina.git) (A lightweight, minimal React.js frontend for interacting with Ollama servers)
+- [Tiny Notepad](https://pypi.org/project/tiny-notepad) (A lightweight, notepad-like interface to chat with ollama available on PyPI)
+- [macLlama (macOS native)](https://github.com/hellotunamayo/macLlama) (A native macOS GUI application for interacting with Ollama models, featuring a chat interface.)
+- [GPTranslate](https://github.com/philberndt/GPTranslate) (A fast and lightweight, AI powered desktop translation application written with Rust and Tauri. Features real-time translation with OpenAI/Azure/Ollama.)
+- [ollama launcher](https://github.com/NGC13009/ollama-launcher) (A launcher for Ollama, aiming to provide users with convenient functions such as ollama server launching, management, or configuration.)
+- [ai-hub](https://github.com/Aj-Seven/ai-hub) (AI Hub supports multiple models via API keys and Chat support via Ollama API.)
+- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) (Open source document management system to organize, tag, search, and automate your files with powerful Ollama driven workflows.)
+- [Serene Pub](https://github.com/doolijb/serene-pub) (Beginner friendly, open source AI Roleplaying App for Windows, Mac OS and Linux. Search, download and use models with Ollama all inside the app.)
+- [Andes](https://github.com/aqerd/andes) (A Visual Studio Code extension that provides a local UI interface for Ollama models)
+- [KDeps](https://github.com/kdeps/kdeps) (Kdeps is an offline-first AI framework for building Dockerized full-stack AI applications declaratively using Apple PKL and integrates APIs with Ollama on the backend.)
+- [Clueless](https://github.com/KashyapTan/clueless) (Open Source & Local Cluely: A desktop application LLM assistant to help you talk to anything on your screen using locally served Ollama models. Also undetectable to screenshare)
+- [ollama-co2](https://github.com/carbonatedWaterOrg/ollama-co2) (FastAPI web interface for monitoring and managing local and remote Ollama servers with real-time model monitoring and concurrent downloads)
+- [Hillnote](https://hillnote.com) (A Markdown-first workspace designed to supercharge your AI workflow. Create documents ready to integrate with Claude, ChatGPT, Gemini, Cursor, and more - all while keeping your work on your device.)
+- [Stakpak](https://github.com/stakpak/agent) (An open source, vendor neutral DevOps agent that works with any model, and any stack, for teams who just want to ship)

-#### Web
-
- [Open WebUI](https://github.com/open-webui/open-webui) - Extensible, self-hosted AI interface
- [Onyx](https://github.com/onyx-dot-app/onyx) - Connected AI workspace
- [LibreChat](https://github.com/danny-avila/LibreChat) - Enhanced ChatGPT clone with multi-provider support
- [Lobe Chat](https://github.com/lobehub/lobe-chat) - Modern chat framework with plugin ecosystem ([docs](https://lobehub.com/docs/self-hosting/examples/ollama))
- [NextChat](https://github.com/ChatGPTNextWeb/ChatGPT-Next-Web) - Cross-platform ChatGPT UI ([docs](https://docs.nextchat.dev/models/ollama))
- [Perplexica](https://github.com/ItzCrazyKns/Perplexica) - AI-powered search engine, open-source Perplexity alternative
- [big-AGI](https://github.com/enricoros/big-AGI) - AI suite for professionals
- [Lollms WebUI](https://github.com/ParisNeo/lollms-webui) - Multi-model web interface
- [ChatOllama](https://github.com/sugarforever/chat-ollama) - Chatbot with knowledge bases
- [Bionic GPT](https://github.com/bionic-gpt/bionic-gpt) - On-premise AI platform
- [Chatbot UI](https://github.com/ivanfioravanti/chatbot-ollama) - ChatGPT-style web interface
- [Hollama](https://github.com/fmaclen/hollama) - Minimal web interface
- [Chatbox](https://github.com/Bin-Huang/Chatbox) - Desktop and web AI client
- [chat](https://github.com/swuecho/chat) - Chat web app for teams
- [Ollama RAG Chatbot](https://github.com/datvodinh/rag-chatbot.git) - Chat with multiple PDFs using RAG
- [Tkinter-based client](https://github.com/chyok/ollama-gui) - Python desktop client
-
-#### Desktop
-
- [Dify.AI](https://github.com/langgenius/dify) - LLM app development platform
- [AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) - All-in-one AI app for Mac, Windows, and Linux
- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid) - Cross-platform mobile and desktop client
- [Witsy](https://github.com/nbonamy/witsy) - AI desktop app for Mac, Windows, and Linux
- [Cherry Studio](https://github.com/kangfenmao/cherry-studio) - Multi-provider desktop client
- [Ollama App](https://github.com/JHubi1/ollama-app) - Multi-platform client for desktop and mobile
- [PyGPT](https://github.com/szczyglis-dev/py-gpt) - AI desktop assistant for Linux, Windows, and Mac
- [Alpaca](https://github.com/Jeffser/Alpaca) - GTK4 client for Linux and macOS
- [SwiftChat](https://github.com/aws-samples/swift-chat) - Cross-platform including iOS, Android, and Apple Vision Pro
- [Enchanted](https://github.com/AugustDev/enchanted) - Native macOS and iOS client
- [RWKV-Runner](https://github.com/josStorer/RWKV-Runner) - Multi-model desktop runner
- [Ollama Grid Search](https://github.com/dezoito/ollama-grid-search) - Evaluate and compare models
- [macai](https://github.com/Renset/macai) - macOS client for Ollama and ChatGPT
- [AI Studio](https://github.com/MindWorkAI/AI-Studio) - Multi-provider desktop IDE
- [Reins](https://github.com/ibrahimcetin/reins) - Parameter tuning and reasoning model support
- [ConfiChat](https://github.com/1runeberg/confichat) - Privacy-focused with optional encryption
- [LLocal.in](https://github.com/kartikm7/llocal) - Electron desktop client
- [MindMac](https://mindmac.app) - AI chat client for Mac
- [Msty](https://msty.app) - Multi-model desktop client
- [BoltAI for Mac](https://boltai.com) - AI chat client for Mac
- [IntelliBar](https://intellibar.app/) - AI-powered assistant for macOS
- [Kerlig AI](https://www.kerlig.com/) - AI writing assistant for macOS
- [Hillnote](https://hillnote.com) - Markdown-first AI workspace
- [Perfect Memory AI](https://www.perfectmemory.ai/) - Productivity AI personalized by screen and meeting history
-
-#### Mobile
-
- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) - One-click Ollama on Android
-
-> SwiftChat, Enchanted, Maid, Ollama App, Reins, and ConfiChat listed above also support mobile platforms.
-
-### Code Editors & Development
-
- [Cline](https://github.com/cline/cline) - VS Code extension for multi-file/whole-repo coding
- [Continue](https://github.com/continuedev/continue) - Open-source AI code assistant for any IDE
- [Void](https://github.com/voideditor/void) - Open source AI code editor, Cursor alternative
- [Copilot for Obsidian](https://github.com/logancyang/obsidian-copilot) - AI assistant for Obsidian
- [twinny](https://github.com/rjmacarthy/twinny) - Copilot and Copilot chat alternative
- [gptel Emacs client](https://github.com/karthink/gptel) - LLM client for Emacs
- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) - Use Ollama as GitHub Copilot
- [Obsidian Local GPT](https://github.com/pfrankov/obsidian-local-gpt) - Local AI for Obsidian
- [Ellama Emacs client](https://github.com/s-kostyaev/ellama) - LLM tool for Emacs
- [orbiton](https://github.com/xyproto/orbiton) - Config-free text editor with Ollama tab completion
- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) - Sublime Text 4 AI assistant
- [VT Code](https://github.com/vinhnx/vtcode) - Rust-based terminal coding agent with Tree-sitter
- [QodeAssist](https://github.com/Palm1r/QodeAssist) - AI coding assistant for Qt Creator
- [AI Toolkit for VS Code](https://aka.ms/ai-tooklit/ollama-docs) - Microsoft-official VS Code extension
- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama) - Natural language interface for computers
-
-### Libraries & SDKs
-
- [LiteLLM](https://github.com/BerriAI/litellm) - Unified API for 100+ LLM providers
- [Semantic Kernel](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama) - Microsoft AI orchestration SDK
- [LangChain4j](https://github.com/langchain4j/langchain4j) - Java LangChain ([example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java))
- [LangChainGo](https://github.com/tmc/langchaingo/) - Go LangChain ([example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example))
- [Spring AI](https://github.com/spring-projects/spring-ai) - Spring framework AI support ([docs](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html))
- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
- [Ollama for Ruby](https://github.com/crmne/ruby_llm) - Ruby LLM library
- [any-llm](https://github.com/mozilla-ai/any-llm) - Unified LLM interface by Mozilla
- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp) - .NET SDK
- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) - Rust LangChain ([example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs))
- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) - Java agent framework ([example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama))
- [Elixir LangChain](https://github.com/brainlid/langchain) - Elixir LangChain
- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs) - Rust SDK
- [LangChain for .NET](https://github.com/tryAGI/LangChain) - .NET LangChain ([example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs))
- [chromem-go](https://github.com/philippgille/chromem-go) - Go vector database with Ollama embeddings ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
- [LangChainDart](https://github.com/davidmigloz/langchain_dart) - Dart LangChain
- [LlmTornado](https://github.com/lofcz/llmtornado) - Unified C# interface for multiple inference APIs
- [Ollama4j for Java](https://github.com/ollama4j/ollama4j) - Java SDK
- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel) - Laravel integration
- [Ollama for Swift](https://github.com/mattt/ollama-swift) - Swift SDK
- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama) - Data framework for LLM apps
- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md) - AI pipeline framework
- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama) - Google AI framework
- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp) - C++ SDK
- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) - Julia LLM toolkit ([example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama))
- [Ollama for R - rollama](https://github.com/JBGruber/rollama) - R SDK
- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama) - AI gateway
- [Testcontainers](https://testcontainers.com/modules/ollama/) - Container-based testing
- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama) - PHP AI framework
-
-### Frameworks & Agents
-
- [AutoGPT](https://github.com/Significant-Gravitas/AutoGPT/blob/master/docs/content/platform/ollama.md) - Autonomous AI agent platform
- [crewAI](https://github.com/crewAIInc/crewAI) - Multi-agent orchestration framework
- [Strands Agents](https://github.com/strands-agents/sdk-python) - Model-driven agent building by AWS
- [Cheshire Cat](https://github.com/cheshire-cat-ai/core) - AI assistant framework
- [any-agent](https://github.com/mozilla-ai/any-agent) - Unified agent framework interface by Mozilla
- [Stakpak](https://github.com/stakpak/agent) - Open source DevOps agent
- [Hexabot](https://github.com/hexastack/hexabot) - Conversational AI builder
- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) - Multi-agent orchestration ([docs](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama))
-
-### RAG & Knowledge Bases
-
- [RAGFlow](https://github.com/infiniflow/ragflow) - RAG engine based on deep document understanding
- [R2R](https://github.com/SciPhi-AI/R2R) - Open-source RAG engine
- [MaxKB](https://github.com/1Panel-dev/MaxKB/) - Ready-to-use RAG chatbot
- [Minima](https://github.com/dmayboroda/minima) - On-premises or fully local RAG
- [Chipper](https://github.com/TilmanGriesel/chipper) - AI interface with Haystack RAG
- [ARGO](https://github.com/xark-argo/argo) - RAG and deep research on Mac/Windows/Linux
- [Archyve](https://github.com/nickthecook/archyve) - RAG-enabling document library
- [Casibase](https://casibase.org) - AI knowledge base with RAG and SSO
- [BrainSoup](https://www.nurgo-software.com/products/brainsoup) - Native client with RAG and multi-agent automation
-
-### Bots & Messaging
-
- [LangBot](https://github.com/RockChinQ/LangBot) - Multi-platform messaging bots with agents and RAG
- [AstrBot](https://github.com/Soulter/AstrBot/) - Multi-platform chatbot with RAG and plugins
- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) - TypeScript Discord bot
- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram) - Telegram bot
- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) - Telegram bot for roleplay
-
-### Terminal & CLI
-
- [aichat](https://github.com/sigoden/aichat) - All-in-one LLM CLI with Shell Assistant, RAG, and AI tools
- [oterm](https://github.com/ggozad/oterm) - Terminal client for Ollama
- [gollama](https://github.com/sammcj/gollama) - Go-based model manager for Ollama
- [tlm](https://github.com/yusufcanb/tlm) - Local shell copilot
- [tenere](https://github.com/pythops/tenere) - TUI for LLMs
- [ParLlama](https://github.com/paulrobello/parllama) - TUI for Ollama
- [llm-ollama](https://github.com/taketwo/llm-ollama) - Plugin for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/)
- [ShellOracle](https://github.com/djcopley/ShellOracle) - Shell command suggestions
- [LLM-X](https://github.com/mrdjohnson/llm-x) - Progressive web app for LLMs
- [cmdh](https://github.com/pgibler/cmdh) - Natural language to shell commands
- [VT](https://github.com/vinhnx/vt.ai) - Minimal multimodal AI chat app
-
-### Productivity & Apps
-
- [AppFlowy](https://github.com/AppFlowy-IO/AppFlowy) - AI collaborative workspace, self-hostable Notion alternative
- [Screenpipe](https://github.com/mediar-ai/screenpipe) - 24/7 screen and mic recording with AI-powered search
- [Vibe](https://github.com/thewh1teagle/vibe) - Transcribe and analyze meetings
- [Page Assist](https://github.com/n4ze3m/page-assist) - Chrome extension for AI-powered browsing
- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) - Private, on-device browser AI assistant
- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server) - Security proxy for Ollama
- [1Panel](https://github.com/1Panel-dev/1Panel/) - Web-based Linux server management
- [Writeopia](https://github.com/Writeopia/Writeopia) - Text editor with Ollama integration
- [QA-Pilot](https://github.com/reid41/QA-Pilot) - GitHub code repository understanding
- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama) - Ollama in Raycast
- [Painting Droid](https://github.com/mateuszmigas/painting-droid) - Painting app with AI integrations
- [Serene Pub](https://github.com/doolijb/serene-pub) - AI roleplaying app
- [Mayan EDMS](https://gitlab.com/mayan-edms/mayan-edms) - Document management with Ollama workflows
- [TagSpaces](https://www.tagspaces.org) - File management with [AI tagging](https://docs.tagspaces.org/ai/)
-
-### Observability & Monitoring
-
- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) - Debug, evaluate, and monitor LLM applications
- [OpenLIT](https://github.com/openlit/openlit) - OpenTelemetry-native monitoring for Ollama and GPUs
- [Lunary](https://lunary.ai/docs/integrations/ollama) - LLM observability with analytics and PII masking
- [Langfuse](https://langfuse.com/docs/integrations/ollama) - Open source LLM observability
- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) - AI observability and evaluation for agents
- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) - Open source LLM observability
-
-### Database & Embeddings
-
- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database ([guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md))
- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) - Connect Ollama with 200+ data platforms
- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) - Embeddable vector database for Go ([example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama))
- [Kangaroo](https://github.com/dbkangaroo/kangaroo) - AI-powered SQL client
-
-### Infrastructure & Deployment
-
-#### Cloud
+### Cloud

 - [Google Cloud](https://cloud.google.com/run/docs/tutorials/gpu-gemma2-with-ollama)
 - [Fly.io](https://fly.io/docs/python/do-more/add-ollama/)
 - [Koyeb](https://www.koyeb.com/deploy/ollama)
- [Harbor](https://github.com/av/harbor) - Containerized LLM toolkit with Ollama as default backend

-#### Package Managers
+### Tutorial
+
+- [handy-ollama](https://github.com/datawhalechina/handy-ollama) (Chinese Tutorial for Ollama by [Datawhale ](https://github.com/datawhalechina) - China's Largest Open Source AI Learning Community)
+
+### Terminal
+
+- [oterm](https://github.com/ggozad/oterm)
+- [Ellama Emacs client](https://github.com/s-kostyaev/ellama)
+- [Emacs client](https://github.com/zweifisch/ollama)
+- [neollama](https://github.com/paradoxical-dev/neollama) UI client for interacting with models from within Neovim
+- [gen.nvim](https://github.com/David-Kunz/gen.nvim)
+- [ollama.nvim](https://github.com/nomnivore/ollama.nvim)
+- [ollero.nvim](https://github.com/marco-souza/ollero.nvim)
+- [ollama-chat.nvim](https://github.com/gerazov/ollama-chat.nvim)
+- [ogpt.nvim](https://github.com/huynle/ogpt.nvim)
+- [gptel Emacs client](https://github.com/karthink/gptel)
+- [Oatmeal](https://github.com/dustinblackman/oatmeal)
+- [cmdh](https://github.com/pgibler/cmdh)
+- [ooo](https://github.com/npahlfer/ooo)
+- [shell-pilot](https://github.com/reid41/shell-pilot)(Interact with models via pure shell scripts on Linux or macOS)
+- [tenere](https://github.com/pythops/tenere)
+- [llm-ollama](https://github.com/taketwo/llm-ollama) for [Datasette's LLM CLI](https://llm.datasette.io/en/stable/).
+- [typechat-cli](https://github.com/anaisbetts/typechat-cli)
+- [ShellOracle](https://github.com/djcopley/ShellOracle)
+- [tlm](https://github.com/yusufcanb/tlm)
+- [podman-ollama](https://github.com/ericcurtin/podman-ollama)
+- [gollama](https://github.com/sammcj/gollama)
+- [ParLlama](https://github.com/paulrobello/parllama)
+- [Ollama eBook Summary](https://github.com/cognitivetech/ollama-ebook-summary/)
+- [Ollama Mixture of Experts (MOE) in 50 lines of code](https://github.com/rapidarchitect/ollama_moe)
+- [vim-intelligence-bridge](https://github.com/pepo-ec/vim-intelligence-bridge) Simple interaction of "Ollama" with the Vim editor
+- [x-cmd ollama](https://x-cmd.com/mod/ollama)
+- [bb7](https://github.com/drunkwcodes/bb7)
+- [SwollamaCLI](https://github.com/marcusziade/Swollama) bundled with the Swollama Swift package. [Demo](https://github.com/marcusziade/Swollama?tab=readme-ov-file#cli-usage)
+- [aichat](https://github.com/sigoden/aichat) All-in-one LLM CLI tool featuring Shell Assistant, Chat-REPL, RAG, AI tools & agents, with access to OpenAI, Claude, Gemini, Ollama, Groq, and more.
+- [PowershAI](https://github.com/rrg92/powershai) PowerShell module that brings AI to terminal on Windows, including support for Ollama
+- [DeepShell](https://github.com/Abyss-c0re/deepshell) Your self-hosted AI assistant. Interactive Shell, Files and Folders analysis.
+- [orbiton](https://github.com/xyproto/orbiton) Configuration-free text editor and IDE with support for tab completion with Ollama.
+- [orca-cli](https://github.com/molbal/orca-cli) Ollama Registry CLI Application - Browse, pull, and download models from Ollama Registry in your terminal.
+- [GGUF-to-Ollama](https://github.com/jonathanhecl/gguf-to-ollama) - Importing GGUF to Ollama made easy (multiplatform)
+- [AWS-Strands-With-Ollama](https://github.com/rapidarchitect/ollama_strands) - AWS Strands Agents with Ollama Examples
+- [ollama-multirun](https://github.com/attogram/ollama-multirun) - A bash shell script to run a single prompt against any or all of your locally installed ollama models, saving the output and performance statistics as easily navigable web pages. ([Demo](https://attogram.github.io/ai_test_zone/))
+- [ollama-bash-toolshed](https://github.com/attogram/ollama-bash-toolshed) - Bash scripts to chat with tool using models. Add new tools to your shed with ease. Runs on Ollama.
+- [hle-eval-ollama](https://github.com/mags0ft/hle-eval-ollama) - Runs benchmarks like "Humanity's Last Exam" (HLE) on your favorite local Ollama models and evaluates the quality of their responses
+- [VT Code](https://github.com/vinhnx/vtcode) - VT Code is a Rust-based terminal coding agent with semantic code intelligence via Tree-sitter. Ollama integration for running local/cloud models with configurable endpoints.
+
+### Apple Vision Pro
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Cross-platform AI chat app supporting Apple Vision Pro via "Designed for iPad")
+- [Enchanted](https://github.com/AugustDev/enchanted)
+
+### Database
+
+- [pgai](https://github.com/timescale/pgai) - PostgreSQL as a vector database (Create and search embeddings from Ollama models using pgvector)
+  - [Get started guide](https://github.com/timescale/pgai/blob/main/docs/vectorizer-quick-start.md)
+- [MindsDB](https://github.com/mindsdb/mindsdb/blob/staging/mindsdb/integrations/handlers/ollama_handler/README.md) (Connects Ollama models with nearly 200 data platforms and apps)
+- [chromem-go](https://github.com/philippgille/chromem-go/blob/v0.5.0/embed_ollama.go) with [example](https://github.com/philippgille/chromem-go/tree/v0.5.0/examples/rag-wikipedia-ollama)
+- [Kangaroo](https://github.com/dbkangaroo/kangaroo) (AI-powered SQL client and admin tool for popular databases)
+
+### Package managers

 - [Pacman](https://archlinux.org/packages/extra/x86_64/ollama/)
- [Homebrew](https://formulae.brew.sh/formula/ollama)
- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Gentoo](https://github.com/gentoo/guru/tree/master/app-misc/ollama)
- [Flox](https://flox.dev/blog/ollama-part-one)
+- [Homebrew](https://formulae.brew.sh/formula/ollama)
+- [Helm Chart](https://artifacthub.io/packages/helm/ollama-helm/ollama)
 - [Guix channel](https://codeberg.org/tusharhero/ollama-guix)
+- [Nix package](https://search.nixos.org/packages?show=ollama&from=0&size=50&sort=relevance&type=packages&query=ollama)
+- [Flox](https://flox.dev/blog/ollama-part-one)
+
+### Libraries
+
+- [LangChain](https://python.langchain.com/docs/integrations/chat/ollama/) and [LangChain.js](https://js.langchain.com/docs/integrations/chat/ollama/) with [example](https://js.langchain.com/docs/tutorials/local_rag/)
+- [Firebase Genkit](https://firebase.google.com/docs/genkit/plugins/ollama)
+- [crewAI](https://github.com/crewAIInc/crewAI)
+- [Yacana](https://remembersoftwares.github.io/yacana/) (User-friendly multi-agent framework for brainstorming and executing predetermined flows with built-in tool integration)
+- [Strands Agents](https://github.com/strands-agents/sdk-python) (A model-driven approach to building AI agents in just a few lines of code)
+- [Spring AI](https://github.com/spring-projects/spring-ai) with [reference](https://docs.spring.io/spring-ai/reference/api/chat/ollama-chat.html) and [example](https://github.com/tzolov/ollama-tools)
+- [LangChainGo](https://github.com/tmc/langchaingo/) with [example](https://github.com/tmc/langchaingo/tree/main/examples/ollama-completion-example)
+- [LangChain4j](https://github.com/langchain4j/langchain4j) with [example](https://github.com/langchain4j/langchain4j-examples/tree/main/ollama-examples/src/main/java)
+- [LangChainRust](https://github.com/Abraxas-365/langchain-rust) with [example](https://github.com/Abraxas-365/langchain-rust/blob/main/examples/llm_ollama.rs)
+- [LangChain for .NET](https://github.com/tryAGI/LangChain) with [example](https://github.com/tryAGI/LangChain/blob/main/examples/LangChain.Samples.OpenAI/Program.cs)
+- [LLPhant](https://github.com/theodo-group/LLPhant?tab=readme-ov-file#ollama)
+- [LlamaIndex](https://docs.llamaindex.ai/en/stable/examples/llm/ollama/) and [LlamaIndexTS](https://ts.llamaindex.ai/modules/llms/available_llms/ollama)
+- [LiteLLM](https://github.com/BerriAI/litellm)
+- [OllamaFarm for Go](https://github.com/presbrey/ollamafarm)
+- [OllamaSharp for .NET](https://github.com/awaescher/OllamaSharp)
+- [Ollama for Ruby](https://github.com/crmne/ruby_llm)
+- [Ollama-rs for Rust](https://github.com/pepperoni21/ollama-rs)
+- [Ollama-hpp for C++](https://github.com/jmont-dev/ollama-hpp)
+- [Ollama4j for Java](https://github.com/ollama4j/ollama4j)
+- [ModelFusion Typescript Library](https://modelfusion.dev/integration/model-provider/ollama)
+- [OllamaKit for Swift](https://github.com/kevinhermawan/OllamaKit)
+- [Ollama for Dart](https://github.com/breitburg/dart-ollama)
+- [Ollama for Laravel](https://github.com/cloudstudio/ollama-laravel)
+- [LangChainDart](https://github.com/davidmigloz/langchain_dart)
+- [Semantic Kernel - Python](https://github.com/microsoft/semantic-kernel/tree/main/python/semantic_kernel/connectors/ai/ollama)
+- [Haystack](https://github.com/deepset-ai/haystack-integrations/blob/main/integrations/ollama.md)
+- [Elixir LangChain](https://github.com/brainlid/langchain)
+- [Ollama for R - rollama](https://github.com/JBGruber/rollama)
+- [Ollama for R - ollama-r](https://github.com/hauselin/ollama-r)
+- [Ollama-ex for Elixir](https://github.com/lebrunel/ollama-ex)
+- [Ollama Connector for SAP ABAP](https://github.com/b-tocs/abap_btocs_ollama)
+- [Testcontainers](https://testcontainers.com/modules/ollama/)
+- [Portkey](https://portkey.ai/docs/welcome/integration-guides/ollama)
+- [PromptingTools.jl](https://github.com/svilupp/PromptingTools.jl) with an [example](https://svilupp.github.io/PromptingTools.jl/dev/examples/working_with_ollama)
+- [LlamaScript](https://github.com/Project-Llama/llamascript)
+- [llm-axe](https://github.com/emirsahin1/llm-axe) (Python Toolkit for Building LLM Powered Apps)
+- [Gollm](https://docs.gollm.co/examples/ollama-example)
+- [Gollama for Golang](https://github.com/jonathanhecl/gollama)
+- [Ollamaclient for Golang](https://github.com/xyproto/ollamaclient)
+- [High-level function abstraction in Go](https://gitlab.com/tozd/go/fun)
+- [Ollama PHP](https://github.com/ArdaGnsrn/ollama-php)
+- [Agents-Flex for Java](https://github.com/agents-flex/agents-flex) with [example](https://github.com/agents-flex/agents-flex/tree/main/agents-flex-llm/agents-flex-llm-ollama/src/test/java/com/agentsflex/llm/ollama)
+- [Parakeet](https://github.com/parakeet-nest/parakeet) is a GoLang library, made to simplify the development of small generative AI applications with Ollama.
+- [Haverscript](https://github.com/andygill/haverscript) with [examples](https://github.com/andygill/haverscript/tree/main/examples)
+- [Ollama for Swift](https://github.com/mattt/ollama-swift)
+- [Swollama for Swift](https://github.com/guitaripod/Swollama) with [DocC](https://guitaripod.github.io/Swollama/documentation/swollama)
+- [GoLamify](https://github.com/prasad89/golamify)
+- [Ollama for Haskell](https://github.com/tusharad/ollama-haskell)
+- [multi-llm-ts](https://github.com/nbonamy/multi-llm-ts) (A Typescript/JavaScript library allowing access to different LLM in a unified API)
+- [LlmTornado](https://github.com/lofcz/llmtornado) (C# library providing a unified interface for major FOSS & Commercial inference APIs)
+- [Ollama for Zig](https://github.com/dravenk/ollama-zig)
+- [Abso](https://github.com/lunary-ai/abso) (OpenAI-compatible TypeScript SDK for any LLM provider)
+- [Nichey](https://github.com/goodreasonai/nichey) is a Python package for generating custom wikis for your research topic
+- [Ollama for D](https://github.com/kassane/ollama-d)
+- [OllamaPlusPlus](https://github.com/HardCodeDev777/OllamaPlusPlus) (Very simple C++ library for Ollama)
+- [any-llm](https://github.com/mozilla-ai/any-llm) (A single interface to use different llm providers by [mozilla.ai](https://www.mozilla.ai/))
+- [any-agent](https://github.com/mozilla-ai/any-agent) (A single interface to use and evaluate different agent frameworks by [mozilla.ai](https://www.mozilla.ai/))
+- [Neuro SAN](https://github.com/cognizant-ai-lab/neuro-san-studio) (Data-driven multi-agent orchestration framework) with [example](https://github.com/cognizant-ai-lab/neuro-san-studio/blob/main/docs/user_guide.md#ollama)
+- [achatbot-go](https://github.com/ai-bot-pro/achatbot-go) a multimodal(text/audio/image) chatbot.
+- [Ollama Bash Lib](https://github.com/attogram/ollama-bash-lib) - A Bash Library for Ollama. Run LLM prompts straight from your shell, and more
+
+### Mobile
+
+- [SwiftChat](https://github.com/aws-samples/swift-chat) (Lightning-fast Cross-platform AI chat app with native UI for Android, iOS, and iPad)
+- [Enchanted](https://github.com/AugustDev/enchanted)
+- [Maid](https://github.com/Mobile-Artificial-Intelligence/maid)
+- [Ollama App](https://github.com/JHubi1/ollama-app) (Modern and easy-to-use multi-platform client for Ollama)
+- [ConfiChat](https://github.com/1runeberg/confichat) (Lightweight, standalone, multi-platform, and privacy-focused LLM chat interface with optional encryption)
+- [Ollama Android Chat](https://github.com/sunshine0523/OllamaServer) (No need for Termux, start the Ollama service with one click on an Android device)
+- [Reins](https://github.com/ibrahimcetin/reins) (Easily tweak parameters, customize system prompts per chat, and enhance your AI experiments with reasoning model support.)
+
+### Extensions & Plugins
+
+- [Raycast extension](https://github.com/MassimilianoPasquini97/raycast_ollama)
+- [Discollama](https://github.com/mxyng/discollama) (Discord bot inside the Ollama discord channel)
+- [Continue](https://github.com/continuedev/continue)
+- [Vibe](https://github.com/thewh1teagle/vibe) (Transcribe and analyze meetings with Ollama)
+- [Obsidian Ollama plugin](https://github.com/hinterdupfinger/obsidian-ollama)
+- [Logseq Ollama plugin](https://github.com/omagdy7/ollama-logseq)
+- [NotesOllama](https://github.com/andersrex/notesollama) (Apple Notes Ollama plugin)
+- [Dagger Chatbot](https://github.com/samalba/dagger-chatbot)
+- [Discord AI Bot](https://github.com/mekb-turtle/discord-ai-bot)
+- [Ollama Telegram Bot](https://github.com/ruecat/ollama-telegram)
+- [Hass Ollama Conversation](https://github.com/ej52/hass-ollama-conversation)
+- [Rivet plugin](https://github.com/abrenneke/rivet-plugin-ollama)
+- [Obsidian BMO Chatbot plugin](https://github.com/longy2k/obsidian-bmo-chatbot)
+- [Cliobot](https://github.com/herval/cliobot) (Telegram bot with Ollama support)
+- [Copilot for Obsidian plugin](https://github.com/logancyang/obsidian-copilot)
+- [Obsidian Local GPT plugin](https://github.com/pfrankov/obsidian-local-gpt)
+- [Open Interpreter](https://docs.openinterpreter.com/language-model-setup/local-models/ollama)
+- [Llama Coder](https://github.com/ex3ndr/llama-coder) (Copilot alternative using Ollama)
+- [Ollama Copilot](https://github.com/bernardo-bruning/ollama-copilot) (Proxy that allows you to use Ollama as a copilot like GitHub Copilot)
+- [twinny](https://github.com/rjmacarthy/twinny) (Copilot and Copilot chat alternative using Ollama)
+- [Wingman-AI](https://github.com/RussellCanfield/wingman-ai) (Copilot code and chat alternative using Ollama and Hugging Face)
+- [Page Assist](https://github.com/n4ze3m/page-assist) (Chrome Extension)
+- [Plasmoid Ollama Control](https://github.com/imoize/plasmoid-ollamacontrol) (KDE Plasma extension that allows you to quickly manage/control Ollama model)
+- [AI Telegram Bot](https://github.com/tusharhero/aitelegrambot) (Telegram bot using Ollama in backend)
+- [AI ST Completion](https://github.com/yaroslavyaroslav/OpenAI-sublime-text) (Sublime Text 4 AI assistant plugin with Ollama support)
+- [Discord-Ollama Chat Bot](https://github.com/kevinthedang/discord-ollama) (Generalized TypeScript Discord Bot w/ Tuning Documentation)
+- [ChatGPTBox: All in one browser extension](https://github.com/josStorer/chatGPTBox) with [Integrating Tutorial](https://github.com/josStorer/chatGPTBox/issues/616#issuecomment-1975186467)
+- [Discord AI chat/moderation bot](https://github.com/rapmd73/Companion) Chat/moderation bot written in python. Uses Ollama to create personalities.
+- [Headless Ollama](https://github.com/nischalj10/headless-ollama) (Scripts to automatically install ollama client & models on any OS for apps that depend on ollama server)
+- [Terraform AWS Ollama & Open WebUI](https://github.com/xuyangbocn/terraform-aws-self-host-llm) (A Terraform module to deploy on AWS a ready-to-use Ollama service, together with its front-end Open WebUI service.)
+- [node-red-contrib-ollama](https://github.com/jakubburkiewicz/node-red-contrib-ollama)
+- [Local AI Helper](https://github.com/ivostoykov/localAI) (Chrome and Firefox extensions that enable interactions with the active tab and customisable API endpoints. Includes secure storage for user prompts.)
+- [LSP-AI](https://github.com/SilasMarvin/lsp-ai) (Open-source language server for AI-powered functionality)
+- [QodeAssist](https://github.com/Palm1r/QodeAssist) (AI-powered coding assistant plugin for Qt Creator)
+- [Obsidian Quiz Generator plugin](https://github.com/ECuiDev/obsidian-quiz-generator)
+- [AI Summary Helper plugin](https://github.com/philffm/ai-summary-helper)
+- [TextCraft](https://github.com/suncloudsmoon/TextCraft) (Copilot in Word alternative using Ollama)
+- [Alfred Ollama](https://github.com/zeitlings/alfred-ollama) (Alfred Workflow)
+- [TextLLaMA](https://github.com/adarshM84/TextLLaMA) A Chrome Extension that helps you write emails, correct grammar, and translate into any language
+- [Simple-Discord-AI](https://github.com/zyphixor/simple-discord-ai)
+- [LLM Telegram Bot](https://github.com/innightwolfsleep/llm_telegram_bot) (telegram bot, primary for RP. Oobabooga-like buttons, [A1111](https://github.com/AUTOMATIC1111/stable-diffusion-webui) API integration e.t.c)
+- [mcp-llm](https://github.com/sammcj/mcp-llm) (MCP Server to allow LLMs to call other LLMs)
+- [SimpleOllamaUnity](https://github.com/HardCodeDev777/SimpleOllamaUnity) (Unity Engine extension for communicating with Ollama in a few lines of code. Also works at runtime)
+- [UnityCodeLama](https://github.com/HardCodeDev777/UnityCodeLama) (Unity Editor tool to analyze scripts via Ollama)
+- [NativeMind](https://github.com/NativeMindBrowser/NativeMindExtension) (Private, on-device AI Assistant, no cloud dependencies)
+- [GMAI - Gradle Managed AI](https://gmai.premex.se/) (Gradle plugin for automated Ollama lifecycle management during build phases)
+- [NOMYO Router](https://github.com/nomyo-ai/nomyo-router) (A transparent Ollama proxy with model deployment aware routing which auto-manages multiple Ollama instances in a given network)
+
+### Supported backends
+
+- [llama.cpp](https://github.com/ggml-org/llama.cpp) project founded by Georgi Gerganov.
+
+### Observability
+
+- [Opik](https://www.comet.com/docs/opik/cookbook/ollama) is an open-source platform to debug, evaluate, and monitor your LLM applications, RAG systems, and agentic workflows with comprehensive tracing, automated evaluations, and production-ready dashboards. Opik supports native integration to Ollama.
+- [Lunary](https://lunary.ai/docs/integrations/ollama) is the leading open-source LLM observability platform. It provides a variety of enterprise-grade features such as real-time analytics, prompt templates management, PII masking, and comprehensive agent tracing.
+- [OpenLIT](https://github.com/openlit/openlit) is an OpenTelemetry-native tool for monitoring Ollama Applications & GPUs using traces and metrics.
+- [HoneyHive](https://docs.honeyhive.ai/integrations/ollama) is an AI observability and evaluation platform for AI agents. Use HoneyHive to evaluate agent performance, interrogate failures, and monitor quality in production.
+- [Langfuse](https://langfuse.com/docs/integrations/ollama) is an open source LLM observability platform that enables teams to collaboratively monitor, evaluate and debug AI applications.
+- [MLflow Tracing](https://mlflow.org/docs/latest/llms/tracing/index.html#automatic-tracing) is an open source LLM observability tool with a convenient API to log and visualize traces, making it easy to debug and evaluate GenAI applications.
+
+### Security
+
+- [Ollama Fortress](https://github.com/ParisNeo/ollama_proxy_server)
--- a/api/client.go
+++ b/api/client.go
@@ -449,16 +449,6 @@ func (c *Client) Version(ctx context.Context) (string, error) {
 	return version.Version, nil
 }

-// CloudStatusExperimental returns whether cloud features are disabled on the server.
-func (c *Client) CloudStatusExperimental(ctx context.Context) (*StatusResponse, error) {
-	var status StatusResponse
-	if err := c.do(ctx, http.MethodGet, "/api/status", nil, &status); err != nil {
-		return nil, err
-	}
-
-	return &status, nil
-}
-
 // Signout will signout a client for a local ollama server.
 func (c *Client) Signout(ctx context.Context) error {
 	return c.do(ctx, http.MethodPost, "/api/signout", nil, nil)
--- a/api/types.go
+++ b/api/types.go
@@ -834,16 +834,6 @@ type TokenResponse struct {
 	Token string `json:"token"`
 }

-type CloudStatus struct {
-	Disabled bool   `json:"disabled"`
-	Source   string `json:"source"`
-}
-
-// StatusResponse is the response from [Client.CloudStatusExperimental].
-type StatusResponse struct {
-	Cloud CloudStatus `json:"cloud"`
-}
-
 // GenerateResponse is the response passed into [GenerateResponseFunc].
 type GenerateResponse struct {
 	// Model is the model name that generated the response.
--- a/app/server/server.go
+++ b/app/server/server.go
@@ -205,11 +205,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 		return nil, err
 	}

-	cloudDisabled, err := s.store.CloudDisabled()
-	if err != nil {
-		return nil, err
-	}
-
 	cmd := commandContext(ctx, s.bin, "serve")
 	cmd.Stdout, cmd.Stderr = s.log, s.log

@@ -235,11 +230,6 @@ func (s *Server) cmd(ctx context.Context) (*exec.Cmd, error) {
 	if settings.ContextLength > 0 {
 		env["OLLAMA_CONTEXT_LENGTH"] = strconv.Itoa(settings.ContextLength)
 	}
-	if cloudDisabled {
-		env["OLLAMA_NO_CLOUD"] = "1"
-	} else {
-		env["OLLAMA_NO_CLOUD"] = "0"
-	}
 	cmd.Env = []string{}
 	for k, v := range env {
 		cmd.Env = append(cmd.Env, k+"="+v)
--- a/app/server/server_test.go
+++ b/app/server/server_test.go
@@ -111,7 +111,7 @@ func TestServerCmd(t *testing.T) {
 			for _, want := range tt.want {
 				found := false
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, want) {
+					if strings.Contains(env, want) {
 						found = true
 						break
 					}
@@ -123,7 +123,7 @@ func TestServerCmd(t *testing.T) {

 			for _, dont := range tt.dont {
 				for _, env := range cmd.Env {
-					if strings.HasPrefix(env, dont) {
+					if strings.Contains(env, dont) {
 						t.Errorf("unexpected environment variable: %s", env)
 					}
 				}
@@ -136,75 +136,6 @@ func TestServerCmd(t *testing.T) {
 	}
 }

-func TestServerCmdCloudSettingEnv(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		want          string
-	}{
-		{
-			name: "default cloud enabled",
-			want: "OLLAMA_NO_CLOUD=0",
-		},
-		{
-			name:     "env disables cloud",
-			envValue: "1",
-			want:     "OLLAMA_NO_CLOUD=1",
-		},
-		{
-			name:          "config disables cloud",
-			configContent: `{"disable_ollama_cloud": true}`,
-			want:          "OLLAMA_NO_CLOUD=1",
-		},
-		{
-			name:     "invalid env disables cloud",
-			envValue: "invalid",
-			want:     "OLLAMA_NO_CLOUD=1",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpHome := t.TempDir()
-			t.Setenv("HOME", tmpHome)
-			t.Setenv("USERPROFILE", tmpHome)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if tt.configContent != "" {
-				configDir := filepath.Join(tmpHome, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatalf("mkdir config dir: %v", err)
-				}
-				configPath := filepath.Join(configDir, "server.json")
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatalf("write config: %v", err)
-				}
-			}
-
-			st := &store.Store{DBPath: filepath.Join(t.TempDir(), "db.sqlite")}
-			defer st.Close()
-
-			s := &Server{store: st}
-			cmd, err := s.cmd(t.Context())
-			if err != nil {
-				t.Fatalf("s.cmd() error = %v", err)
-			}
-
-			found := false
-			for _, env := range cmd.Env {
-				if env == tt.want {
-					found = true
-					break
-				}
-			}
-			if !found {
-				t.Fatalf("expected environment variable %q in command env", tt.want)
-			}
-		})
-	}
-}
-
 func TestGetInferenceComputer(t *testing.T) {
 	tests := []struct {
 		name string
--- a/app/store/cloud_config.go
+++ b/app/store/cloud_config.go
@@ -1,128 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/ollama/ollama/envconfig"
-)
-
-const serverConfigFilename = "server.json"
-
-type serverConfig struct {
-	DisableOllamaCloud bool `json:"disable_ollama_cloud,omitempty"`
-}
-
-// CloudDisabled returns whether cloud features should be disabled.
-// The source of truth is: OLLAMA_NO_CLOUD OR ~/.ollama/server.json:disable_ollama_cloud.
-func (s *Store) CloudDisabled() (bool, error) {
-	disabled, _, err := s.CloudStatus()
-	return disabled, err
-}
-
-// CloudStatus returns whether cloud is disabled and the source of that decision.
-// Source is one of: "none", "env", "config", "both".
-func (s *Store) CloudStatus() (bool, string, error) {
-	if err := s.ensureDB(); err != nil {
-		return false, "", err
-	}
-
-	configDisabled, err := readServerConfigCloudDisabled()
-	if err != nil {
-		return false, "", err
-	}
-
-	envDisabled := envconfig.NoCloudEnv()
-	return envDisabled || configDisabled, cloudStatusSource(envDisabled, configDisabled), nil
-}
-
-// SetCloudEnabled writes the cloud setting to ~/.ollama/server.json.
-func (s *Store) SetCloudEnabled(enabled bool) error {
-	if err := s.ensureDB(); err != nil {
-		return err
-	}
-	return setCloudEnabled(enabled)
-}
-
-func setCloudEnabled(enabled bool) error {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return err
-	}
-
-	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-		return fmt.Errorf("create server config directory: %w", err)
-	}
-
-	configMap := map[string]any{}
-	if data, err := os.ReadFile(configPath); err == nil {
-		if err := json.Unmarshal(data, &configMap); err != nil {
-			// If the existing file is invalid JSON, overwrite with a fresh object.
-			configMap = map[string]any{}
-		}
-	} else if !errors.Is(err, os.ErrNotExist) {
-		return fmt.Errorf("read server config: %w", err)
-	}
-
-	configMap["disable_ollama_cloud"] = !enabled
-
-	data, err := json.MarshalIndent(configMap, "", "  ")
-	if err != nil {
-		return fmt.Errorf("marshal server config: %w", err)
-	}
-	data = append(data, '\n')
-
-	if err := os.WriteFile(configPath, data, 0o644); err != nil {
-		return fmt.Errorf("write server config: %w", err)
-	}
-
-	return nil
-}
-
-func readServerConfigCloudDisabled() (bool, error) {
-	configPath, err := serverConfigPath()
-	if err != nil {
-		return false, err
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return false, nil
-		}
-		return false, fmt.Errorf("read server config: %w", err)
-	}
-
-	var cfg serverConfig
-	// Invalid or unexpected JSON should not block startup; treat as default.
-	if json.Unmarshal(data, &cfg) == nil {
-		return cfg.DisableOllamaCloud, nil
-	}
-	return false, nil
-}
-
-func serverConfigPath() (string, error) {
-	home, err := os.UserHomeDir()
-	if err != nil {
-		return "", fmt.Errorf("resolve home directory: %w", err)
-	}
-	return filepath.Join(home, ".ollama", serverConfigFilename), nil
-}
-
-func cloudStatusSource(envDisabled bool, configDisabled bool) string {
-	switch {
-	case envDisabled && configDisabled:
-		return "both"
-	case envDisabled:
-		return "env"
-	case configDisabled:
-		return "config"
-	default:
-		return "none"
-	}
-}
--- a/app/store/cloud_config_test.go
+++ b/app/store/cloud_config_test.go
@@ -1,130 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestCloudDisabled(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		wantDisabled  bool
-		wantSource    string
-	}{
-		{
-			name:         "default enabled",
-			wantDisabled: false,
-			wantSource:   "none",
-		},
-		{
-			name:         "env disables cloud",
-			envValue:     "1",
-			wantDisabled: true,
-			wantSource:   "env",
-		},
-		{
-			name:          "config disables cloud",
-			configContent: `{"disable_ollama_cloud": true}`,
-			wantDisabled:  true,
-			wantSource:    "config",
-		},
-		{
-			name:          "env and config",
-			envValue:      "1",
-			configContent: `{"disable_ollama_cloud": false}`,
-			wantDisabled:  true,
-			wantSource:    "env",
-		},
-		{
-			name:          "invalid config is ignored",
-			configContent: `{bad`,
-			wantDisabled:  false,
-			wantSource:    "none",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			tmpHome := t.TempDir()
-			setTestHome(t, tmpHome)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if tt.configContent != "" {
-				configDir := filepath.Join(tmpHome, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatalf("mkdir config dir: %v", err)
-				}
-				configPath := filepath.Join(configDir, serverConfigFilename)
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatalf("write config: %v", err)
-				}
-			}
-
-			s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-			defer s.Close()
-
-			disabled, err := s.CloudDisabled()
-			if err != nil {
-				t.Fatalf("CloudDisabled() error = %v", err)
-			}
-			if disabled != tt.wantDisabled {
-				t.Fatalf("CloudDisabled() = %v, want %v", disabled, tt.wantDisabled)
-			}
-
-			statusDisabled, source, err := s.CloudStatus()
-			if err != nil {
-				t.Fatalf("CloudStatus() error = %v", err)
-			}
-			if statusDisabled != tt.wantDisabled {
-				t.Fatalf("CloudStatus() disabled = %v, want %v", statusDisabled, tt.wantDisabled)
-			}
-			if source != tt.wantSource {
-				t.Fatalf("CloudStatus() source = %v, want %v", source, tt.wantSource)
-			}
-		})
-	}
-}
-
-func TestSetCloudEnabled(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-
-	configDir := filepath.Join(tmpHome, ".ollama")
-	if err := os.MkdirAll(configDir, 0o755); err != nil {
-		t.Fatalf("mkdir config dir: %v", err)
-	}
-	configPath := filepath.Join(configDir, serverConfigFilename)
-	if err := os.WriteFile(configPath, []byte(`{"another_key":"value","disable_ollama_cloud":true}`), 0o644); err != nil {
-		t.Fatalf("seed config: %v", err)
-	}
-
-	s := &Store{DBPath: filepath.Join(tmpHome, "db.sqlite")}
-	defer s.Close()
-
-	if err := s.SetCloudEnabled(true); err != nil {
-		t.Fatalf("SetCloudEnabled(true) error = %v", err)
-	}
-
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("read config: %v", err)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(data, &got); err != nil {
-		t.Fatalf("unmarshal config: %v", err)
-	}
-
-	if got["disable_ollama_cloud"] != false {
-		t.Fatalf("disable_ollama_cloud = %v, want false", got["disable_ollama_cloud"])
-	}
-	if got["another_key"] != "value" {
-		t.Fatalf("another_key = %v, want value", got["another_key"])
-	}
-}
--- a/app/store/database.go
+++ b/app/store/database.go
@@ -14,7 +14,7 @@ import (

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

 // database wraps the SQLite connection.
 // SQLite handles its own locking for concurrent access:
@@ -84,7 +84,6 @@ func (db *database) init() error {
 		sidebar_open BOOLEAN NOT NULL DEFAULT 0,
 		think_enabled BOOLEAN NOT NULL DEFAULT 0,
 		think_level TEXT NOT NULL DEFAULT '',
-		cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0,
 		remote TEXT NOT NULL DEFAULT '', -- deprecated
 		schema_version INTEGER NOT NULL DEFAULT %d
 	);
@@ -245,12 +244,6 @@ func (db *database) migrate() error {
 				return fmt.Errorf("migrate v11 to v12: %w", err)
 			}
 			version = 12
-		case 12:
-			// add cloud_setting_migrated column to settings table
-			if err := db.migrateV12ToV13(); err != nil {
-				return fmt.Errorf("migrate v12 to v13: %w", err)
-			}
-			version = 13
 		default:
 			// If we have a version we don't recognize, just set it to current
 			// This might happen during development
@@ -459,21 +452,6 @@ func (db *database) migrateV11ToV12() error {
 	return nil
 }

-// migrateV12ToV13 adds cloud_setting_migrated to settings.
-func (db *database) migrateV12ToV13() error {
-	_, err := db.conn.Exec(`ALTER TABLE settings ADD COLUMN cloud_setting_migrated BOOLEAN NOT NULL DEFAULT 0`)
-	if err != nil && !duplicateColumnError(err) {
-		return fmt.Errorf("add cloud_setting_migrated column: %w", err)
-	}
-
-	_, err = db.conn.Exec(`UPDATE settings SET schema_version = 13`)
-	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(`
@@ -1130,9 +1108,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, think_enabled, think_level
+		SELECT expose, survey, browser, models, agent, tools, working_dir, context_length, airplane_mode, turbo_enabled, websearch_enabled, selected_model, sidebar_open, think_enabled, think_level 
 		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.ThinkEnabled, &s.ThinkLevel)
+	`).Scan(&s.Expose, &s.Survey, &s.Browser, &s.Models, &s.Agent, &s.Tools, &s.WorkingDir, &s.ContextLength, &s.AirplaneMode, &s.TurboEnabled, &s.WebSearchEnabled, &s.SelectedModel, &s.SidebarOpen, &s.ThinkEnabled, &s.ThinkLevel)
 	if err != nil {
 		return Settings{}, fmt.Errorf("get settings: %w", err)
 	}
@@ -1143,40 +1121,14 @@ func (db *database) getSettings() (Settings, error) {
 func (db *database) setSettings(s Settings) error {
 	_, 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 = ?, think_enabled = ?, think_level = ?
-	`, 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)
+		SET expose = ?, survey = ?, browser = ?, models = ?, agent = ?, tools = ?, working_dir = ?, context_length = ?, airplane_mode = ?, turbo_enabled = ?, websearch_enabled = ?, selected_model = ?, sidebar_open = ?, think_enabled = ?, think_level = ?
+	`, s.Expose, s.Survey, s.Browser, s.Models, s.Agent, s.Tools, s.WorkingDir, s.ContextLength, s.AirplaneMode, s.TurboEnabled, s.WebSearchEnabled, s.SelectedModel, s.SidebarOpen, s.ThinkEnabled, s.ThinkLevel)
 	if err != nil {
 		return fmt.Errorf("set settings: %w", err)
 	}
 	return nil
 }

-func (db *database) isCloudSettingMigrated() (bool, error) {
-	var migrated bool
-	err := db.conn.QueryRow("SELECT cloud_setting_migrated FROM settings").Scan(&migrated)
-	if err != nil {
-		return false, fmt.Errorf("get cloud setting migration status: %w", err)
-	}
-	return migrated, nil
-}
-
-func (db *database) setCloudSettingMigrated(migrated bool) error {
-	_, err := db.conn.Exec("UPDATE settings SET cloud_setting_migrated = ?", migrated)
-	if err != nil {
-		return fmt.Errorf("set cloud setting migration status: %w", err)
-	}
-	return nil
-}
-
-func (db *database) getAirplaneMode() (bool, error) {
-	var airplaneMode bool
-	err := db.conn.QueryRow("SELECT airplane_mode FROM settings").Scan(&airplaneMode)
-	if err != nil {
-		return false, fmt.Errorf("get airplane_mode: %w", err)
-	}
-	return airplaneMode, nil
-}
-
 func (db *database) getWindowSize() (int, int, error) {
 	var width, height int
 	err := db.conn.QueryRow("SELECT window_width, window_height FROM settings").Scan(&width, &height)
--- a/app/store/migration_test.go
+++ b/app/store/migration_test.go
@@ -127,65 +127,6 @@ func TestNoConfigToMigrate(t *testing.T) {
 	}
 }

-func TestCloudMigrationFromAirplaneMode(t *testing.T) {
-	tmpHome := t.TempDir()
-	setTestHome(t, tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	dbPath := filepath.Join(tmpHome, "db.sqlite")
-	db, err := newDatabase(dbPath)
-	if err != nil {
-		t.Fatalf("failed to create database: %v", err)
-	}
-
-	if _, err := db.conn.Exec("UPDATE settings SET airplane_mode = 1, cloud_setting_migrated = 0"); err != nil {
-		db.Close()
-		t.Fatalf("failed to seed airplane migration state: %v", err)
-	}
-	db.Close()
-
-	s := Store{DBPath: dbPath}
-	defer s.Close()
-
-	// Trigger DB initialization + one-time cloud migration.
-	if _, err := s.ID(); err != nil {
-		t.Fatalf("failed to initialize store: %v", err)
-	}
-
-	disabled, err := s.CloudDisabled()
-	if err != nil {
-		t.Fatalf("CloudDisabled() error: %v", err)
-	}
-	if !disabled {
-		t.Fatal("expected cloud to be disabled after migrating airplane_mode=true")
-	}
-
-	configPath := filepath.Join(tmpHome, ".ollama", serverConfigFilename)
-	data, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatalf("failed to read migrated server config: %v", err)
-	}
-
-	var cfg map[string]any
-	if err := json.Unmarshal(data, &cfg); err != nil {
-		t.Fatalf("failed to parse migrated server config: %v", err)
-	}
-	if cfg["disable_ollama_cloud"] != true {
-		t.Fatalf("disable_ollama_cloud = %v, want true", cfg["disable_ollama_cloud"])
-	}
-
-	var airplaneMode, migrated bool
-	if err := s.db.conn.QueryRow("SELECT airplane_mode, cloud_setting_migrated FROM settings").Scan(&airplaneMode, &migrated); err != nil {
-		t.Fatalf("failed to read migration flags from DB: %v", err)
-	}
-	if !airplaneMode {
-		t.Fatal("expected legacy airplane_mode value to remain unchanged")
-	}
-	if !migrated {
-		t.Fatal("expected cloud_setting_migrated to be true")
-	}
-}
-
 const (
 	v1Schema = `
 	CREATE TABLE IF NOT EXISTS settings (
--- a/app/store/store.go
+++ b/app/store/store.go
@@ -149,6 +149,9 @@ type Settings struct {
 	// ContextLength specifies the context length for the ollama server (using OLLAMA_CONTEXT_LENGTH)
 	ContextLength int

+	// AirplaneMode when true, turns off Ollama Turbo features and only uses local models
+	AirplaneMode bool
+
 	// TurboEnabled indicates if Ollama Turbo features are enabled
 	TurboEnabled bool

@@ -256,40 +259,6 @@ func (s *Store) ensureDB() error {
 		}
 	}

-	// Run one-time migration from legacy airplane_mode behavior.
-	if err := s.migrateCloudSetting(database); err != nil {
-		return fmt.Errorf("migrate cloud setting: %w", err)
-	}
-
-	return nil
-}
-
-// migrateCloudSetting migrates legacy airplane_mode into server.json exactly once.
-// After this, cloud state is sourced from server.json OR OLLAMA_NO_CLOUD.
-func (s *Store) migrateCloudSetting(database *database) error {
-	migrated, err := database.isCloudSettingMigrated()
-	if err != nil {
-		return err
-	}
-	if migrated {
-		return nil
-	}
-
-	airplaneMode, err := database.getAirplaneMode()
-	if err != nil {
-		return err
-	}
-
-	if airplaneMode {
-		if err := setCloudEnabled(false); err != nil {
-			return fmt.Errorf("migrate airplane_mode to cloud disabled: %w", err)
-		}
-	}
-
-	if err := database.setCloudSettingMigrated(true); err != nil {
-		return err
-	}
-
 	return nil
 }

--- a/app/store/test_home_test.go
+++ b/app/store/test_home_test.go
@@ -1,11 +0,0 @@
-//go:build windows || darwin
-
-package store
-
-import "testing"
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-}
--- a/app/tools/cloud_policy.go
+++ b/app/tools/cloud_policy.go
@@ -1,35 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"errors"
-
-	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-)
-
-// ensureCloudEnabledForTool checks cloud policy from the connected Ollama server.
-// If policy cannot be determined, this fails closed and blocks the operation.
-func ensureCloudEnabledForTool(ctx context.Context, operation string) error {
-	// Reuse shared message formatting; policy evaluation is still done via
-	// the connected server's /api/status endpoint below.
-	disabledMessage := internalcloud.DisabledError(operation)
-
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	status, err := client.CloudStatusExperimental(ctx)
-	if err != nil {
-		return errors.New(disabledMessage + " (unable to verify server cloud policy)")
-	}
-
-	if status.Cloud.Disabled {
-		return errors.New(disabledMessage)
-	}
-
-	return nil
-}
--- a/app/tools/cloud_policy_test.go
+++ b/app/tools/cloud_policy_test.go
@@ -1,73 +0,0 @@
-//go:build windows || darwin
-
-package tools
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-func TestEnsureCloudEnabledForTool(t *testing.T) {
-	const op = "web search is unavailable"
-	const disabledPrefix = "ollama cloud is disabled: web search is unavailable"
-
-	t.Run("enabled allows tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":false,"source":"none"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		if err := ensureCloudEnabledForTool(context.Background(), op); err != nil {
-			t.Fatalf("expected nil error, got %v", err)
-		}
-	})
-
-	t.Run("disabled blocks tool execution", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path != "/api/status" {
-				http.NotFound(w, r)
-				return
-			}
-			w.Header().Set("Content-Type", "application/json")
-			_, _ = w.Write([]byte(`{"cloud":{"disabled":true,"source":"config"}}`))
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); got != disabledPrefix {
-			t.Fatalf("unexpected error: %q", got)
-		}
-	})
-
-	t.Run("status unavailable fails closed", func(t *testing.T) {
-		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			http.NotFound(w, r)
-		}))
-		t.Cleanup(ts.Close)
-		t.Setenv("OLLAMA_HOST", ts.URL)
-
-		err := ensureCloudEnabledForTool(context.Background(), op)
-		if err == nil {
-			t.Fatal("expected error, got nil")
-		}
-		if got := err.Error(); !strings.Contains(got, disabledPrefix) {
-			t.Fatalf("expected disabled prefix, got %q", got)
-		}
-		if got := err.Error(); !strings.Contains(got, "unable to verify server cloud policy") {
-			t.Fatalf("expected verification failure detail, got %q", got)
-		}
-	})
-}
--- a/app/tools/web_fetch.go
+++ b/app/tools/web_fetch.go
@@ -77,10 +77,6 @@ func (w *WebFetch) Execute(ctx context.Context, args map[string]any) (any, strin
 }

 func performWebFetch(ctx context.Context, targetURL string) (*FetchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web fetch is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := FetchRequest{URL: targetURL}
 	jsonBody, err := json.Marshal(reqBody)
 	if err != nil {
--- a/app/tools/web_search.go
+++ b/app/tools/web_search.go
@@ -93,10 +93,6 @@ func (w *WebSearch) Execute(ctx context.Context, args map[string]any) (any, stri
 }

 func performWebSearch(ctx context.Context, query string, maxResults int) (*SearchResponse, error) {
-	if err := ensureCloudEnabledForTool(ctx, "web search is unavailable"); err != nil {
-		return nil, err
-	}
-
 	reqBody := SearchRequest{Query: query, MaxResults: maxResults}

 	jsonBody, err := json.Marshal(reqBody)
--- a/app/ui/app/codegen/gotypes.gen.ts
+++ b/app/ui/app/codegen/gotypes.gen.ts
@@ -406,6 +406,7 @@ export class Settings {
    Tools: boolean;
    WorkingDir: string;
    ContextLength: number;
+    AirplaneMode: boolean;
    TurboEnabled: boolean;
    WebSearchEnabled: boolean;
    ThinkEnabled: boolean;
@@ -423,6 +424,7 @@ export class Settings {
        this.Tools = source["Tools"];
        this.WorkingDir = source["WorkingDir"];
        this.ContextLength = source["ContextLength"];
+        this.AirplaneMode = source["AirplaneMode"];
        this.TurboEnabled = source["TurboEnabled"];
        this.WebSearchEnabled = source["WebSearchEnabled"];
        this.ThinkEnabled = source["ThinkEnabled"];
--- a/app/ui/app/src/api.ts
+++ b/app/ui/app/src/api.ts
@@ -27,12 +27,6 @@ declare module "@/gotypes" {
 Model.prototype.isCloud = function (): boolean {
  return this.model.endsWith("cloud");
 };
-
-export type CloudStatusSource = "env" | "config" | "both" | "none";
-export interface CloudStatusResponse {
-  disabled: boolean;
-  source: CloudStatusSource;
-}
 // Helper function to convert Uint8Array to base64
 function uint8ArrayToBase64(uint8Array: Uint8Array): string {
  const chunkSize = 0x8000; // 32KB chunks to avoid stack overflow
@@ -291,28 +285,6 @@ export async function updateSettings(settings: Settings): Promise<{
  };
 }

-export async function updateCloudSetting(
-  enabled: boolean,
-): Promise<CloudStatusResponse> {
-  const response = await fetch(`${API_BASE}/api/v1/cloud`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ enabled }),
-  });
-  if (!response.ok) {
-    const error = await response.text();
-    throw new Error(error || "Failed to update cloud setting");
-  }
-
-  const data = await response.json();
-  return {
-    disabled: Boolean(data.disabled),
-    source: (data.source as CloudStatusSource) || "none",
-  };
-}
-
 export async function renameChat(chatId: string, title: string): Promise<void> {
  const response = await fetch(`${API_BASE}/api/v1/chat/${chatId}/rename`, {
    method: "PUT",
@@ -442,16 +414,3 @@ export async function fetchHealth(): Promise<boolean> {
    return false;
  }
 }
-
-export async function getCloudStatus(): Promise<CloudStatusResponse | null> {
-  const response = await fetch(`${API_BASE}/api/v1/cloud`);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch cloud status: ${response.status}`);
-  }
-
-  const data = await response.json();
-  return {
-    disabled: Boolean(data.disabled),
-    source: (data.source as CloudStatusSource) || "none",
-  };
-}
--- a/app/ui/app/src/components/ChatForm.tsx
+++ b/app/ui/app/src/components/ChatForm.tsx
@@ -22,7 +22,6 @@ import { useUser } from "@/hooks/useUser";
 import { DisplayLogin } from "@/components/DisplayLogin";
 import { ErrorEvent, Message } from "@/gotypes";
 import { useSettings } from "@/hooks/useSettings";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
 import { ThinkButton } from "./ThinkButton";
 import { ErrorMessage } from "./ErrorMessage";
 import { processFiles } from "@/utils/fileValidation";
@@ -142,12 +141,12 @@ function ChatForm({
  const {
    settings: {
      webSearchEnabled,
+      airplaneMode,
      thinkEnabled,
      thinkLevel: settingsThinkLevel,
    },
    setSettings,
  } = useSettings();
-  const { cloudDisabled } = useCloudStatus();

  // current supported models for web search
  const modelLower = selectedModel?.model.toLowerCase() || "";
@@ -181,12 +180,6 @@ function ChatForm({
    setSettings,
  ]);

-  useEffect(() => {
-    if (cloudDisabled && webSearchEnabled) {
-      setSettings({ WebSearchEnabled: false });
-    }
-  }, [cloudDisabled, webSearchEnabled, setSettings]);
-
  const removeFile = (index: number) => {
    setMessage((prev) => ({
      ...prev,
@@ -241,19 +234,19 @@ function ChatForm({

  // Determine if login banner should be shown
  const shouldShowLoginBanner =
-    !cloudDisabled &&
    !isLoadingUser &&
    !isAuthenticated &&
-    ((webSearchEnabled && supportsWebSearch) || selectedModel?.isCloud());
+    ((webSearchEnabled && supportsWebSearch) ||
+      (selectedModel?.isCloud() && !airplaneMode));

  // Determine which feature to highlight in the banner
  const getActiveFeatureForBanner = () => {
-    if (cloudDisabled) return null;
    if (!isAuthenticated) {
      if (loginPromptFeature) return loginPromptFeature;
-      if (webSearchEnabled && selectedModel?.isCloud()) return "webSearch";
+      if (webSearchEnabled && selectedModel?.isCloud() && !airplaneMode)
+        return "webSearch";
      if (webSearchEnabled) return "webSearch";
-      if (selectedModel?.isCloud()) return "turbo";
+      if (selectedModel?.isCloud() && !airplaneMode) return "turbo";
    }
    return null;
  };
@@ -276,12 +269,11 @@ function ChatForm({
  useEffect(() => {
    if (
      isAuthenticated ||
-      cloudDisabled ||
-      (!webSearchEnabled && !!selectedModel?.isCloud())
+      (!webSearchEnabled && !!selectedModel?.isCloud() && !airplaneMode)
    ) {
      setLoginPromptFeature(null);
    }
-  }, [isAuthenticated, webSearchEnabled, selectedModel, cloudDisabled]);
+  }, [isAuthenticated, webSearchEnabled, selectedModel, airplaneMode]);

  // When entering edit mode, populate the composition with existing data
  useEffect(() => {
@@ -473,10 +465,6 @@ function ChatForm({
  const handleSubmit = async () => {
    if (!message.content.trim() || isStreaming || isDownloading) return;

-    if (cloudDisabled && selectedModel?.isCloud()) {
-      return;
-    }
-
    // Check if cloud mode is enabled but user is not authenticated
    if (shouldShowLoginBanner) {
      return;
@@ -490,8 +478,7 @@ function ChatForm({
      }),
    );

-    const useWebSearch =
-      supportsWebSearch && webSearchEnabled && !cloudDisabled;
+    const useWebSearch = supportsWebSearch && webSearchEnabled && !airplaneMode;
    const useThink = modelSupportsThinkingLevels
      ? thinkLevel
      : supportsThinkToggling
@@ -912,7 +899,7 @@ function ChatForm({
                )}
                <WebSearchButton
                  ref={webSearchButtonRef}
-                  isVisible={supportsWebSearch && cloudDisabled === false}
+                  isVisible={supportsWebSearch && airplaneMode === false}
                  isActive={webSearchEnabled}
                  onToggle={() => {
                    if (!webSearchEnabled && !isAuthenticated) {
@@ -953,7 +940,6 @@ function ChatForm({
                !isDownloading &&
                (!message.content.trim() ||
                  shouldShowLoginBanner ||
-                  (cloudDisabled && selectedModel?.isCloud()) ||
                  message.fileErrors.length > 0)
              }
              className={`flex items-center justify-center h-9 w-9 rounded-full disabled:cursor-default cursor-pointer bg-black text-white dark:bg-white dark:text-black disabled:opacity-10 focus:outline-none focus:ring-2 focus:ring-blue-500`}
--- a/app/ui/app/src/components/ModelPicker.tsx
+++ b/app/ui/app/src/components/ModelPicker.tsx
@@ -8,7 +8,7 @@ import {
 } from "react";
 import { Model } from "@/gotypes";
 import { useSelectedModel } from "@/hooks/useSelectedModel";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
+import { useSettings } from "@/hooks/useSettings";
 import { useQueryClient } from "@tanstack/react-query";
 import { getModelUpstreamInfo } from "@/api";
 import { ArrowDownTrayIcon } from "@heroicons/react/24/outline";
@@ -34,7 +34,7 @@ export const ModelPicker = forwardRef<
    chatId,
    searchQuery,
  );
-  const { cloudDisabled } = useCloudStatus();
+  const { settings } = useSettings();
  const dropdownRef = useRef<HTMLDivElement>(null);
  const searchInputRef = useRef<HTMLInputElement>(null);
  const queryClient = useQueryClient();
@@ -219,7 +219,7 @@ export const ModelPicker = forwardRef<
            models={models}
            selectedModel={selectedModel}
            onModelSelect={handleModelSelect}
-            cloudDisabled={cloudDisabled}
+            airplaneMode={settings.airplaneMode}
            isOpen={isOpen}
          />
        </div>
@@ -233,13 +233,13 @@ export const ModelList = forwardRef(function ModelList(
    models,
    selectedModel,
    onModelSelect,
-    cloudDisabled,
+    airplaneMode,
    isOpen,
  }: {
    models: Model[];
    selectedModel: Model | null;
    onModelSelect: (model: Model) => void;
-    cloudDisabled: boolean;
+    airplaneMode: boolean;
    isOpen: boolean;
  },
  ref,
@@ -348,7 +348,7 @@ export const ModelList = forwardRef(function ModelList(
                  </svg>
                )}
                {model.digest === undefined &&
-                  (cloudDisabled || !model.isCloud()) && (
+                  (airplaneMode || !model.isCloud()) && (
                    <ArrowDownTrayIcon
                      className="h-4 w-4 text-neutral-500 dark:text-neutral-400"
                      strokeWidth={1.75}
--- a/app/ui/app/src/components/Settings.tsx
+++ b/app/ui/app/src/components/Settings.tsx
@@ -11,7 +11,6 @@ import {
  FolderIcon,
  BoltIcon,
  WrenchIcon,
-  CloudIcon,
  XMarkIcon,
  CogIcon,
  ArrowLeftIcon,
@@ -19,14 +18,8 @@ import {
 import { Settings as SettingsType } from "@/gotypes";
 import { useNavigate } from "@tanstack/react-router";
 import { useUser } from "@/hooks/useUser";
-import { useCloudStatus } from "@/hooks/useCloudStatus";
 import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import {
-  getSettings,
-  type CloudStatusResponse,
-  updateCloudSetting,
-  updateSettings,
-} from "@/api";
+import { getSettings, updateSettings } from "@/api";

 function AnimatedDots() {
  return (
@@ -60,11 +53,6 @@ export default function Settings() {
  const [connectionError, setConnectionError] = useState<string | null>(null);
  const [pollingInterval, setPollingInterval] = useState<number | null>(null);
  const navigate = useNavigate();
-  const {
-    cloudDisabled,
-    cloudStatus,
-    isLoading: cloudStatusLoading,
-  } = useCloudStatus();

  const {
    data: settingsData,
@@ -86,50 +74,6 @@ export default function Settings() {
    },
  });

-  const updateCloudMutation = useMutation({
-    mutationFn: (enabled: boolean) => updateCloudSetting(enabled),
-    onMutate: async (enabled: boolean) => {
-      await queryClient.cancelQueries({ queryKey: ["cloudStatus"] });
-
-      const previous = queryClient.getQueryData<CloudStatusResponse | null>([
-        "cloudStatus",
-      ]);
-      const envForcesDisabled =
-        previous?.source === "env" || previous?.source === "both";
-
-      queryClient.setQueryData<CloudStatusResponse | null>(
-        ["cloudStatus"],
-        previous
-          ? {
-              ...previous,
-              disabled: !enabled || envForcesDisabled,
-            }
-          : {
-              disabled: !enabled,
-              source: "config",
-            },
-      );
-
-      return { previous };
-    },
-    onError: (_error, _enabled, context) => {
-      if (context?.previous !== undefined) {
-        queryClient.setQueryData(["cloudStatus"], context.previous);
-      }
-    },
-    onSuccess: (status) => {
-      queryClient.setQueryData<CloudStatusResponse | null>(
-        ["cloudStatus"],
-        status,
-      );
-      queryClient.invalidateQueries({ queryKey: ["models"] });
-      queryClient.invalidateQueries({ queryKey: ["cloudStatus"] });
-
-      setShowSaved(true);
-      setTimeout(() => setShowSaved(false), 1500);
-    },
-  });
-
  useEffect(() => {
    refetchUser();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps
@@ -205,16 +149,12 @@ export default function Settings() {
        Agent: false,
        Tools: false,
        ContextLength: 4096,
+        AirplaneMode: false,
      });
      updateSettingsMutation.mutate(defaultSettings);
    }
  };

-  const cloudOverriddenByEnv =
-    cloudStatus?.source === "env" || cloudStatus?.source === "both";
-  const cloudToggleDisabled =
-    cloudStatusLoading || updateCloudMutation.isPending || cloudOverriddenByEnv;
-
  const handleConnectOllamaAccount = async () => {
    setConnectionError(null);

@@ -297,7 +237,7 @@ export default function Settings() {
        <div className="space-y-4 max-w-2xl mx-auto">
          {/* Connect Ollama Account */}
          <div className="overflow-hidden rounded-xl bg-white dark:bg-neutral-800">
-            <div className="p-4">
+            <div className="p-4 border-b border-neutral-200 dark:border-neutral-800">
              <Field>
                {isLoading ? (
                  // Loading skeleton, this will only happen if the app started recently
@@ -404,34 +344,6 @@ export default function Settings() {
          {/* Local Configuration */}
          <div className="relative overflow-hidden rounded-xl bg-white dark:bg-neutral-800">
            <div className="space-y-4 p-4">
-              <Field>
-                <div className="flex items-start justify-between gap-4">
-                  <div className="flex items-start space-x-3 flex-1">
-                    <CloudIcon className="mt-1 h-5 w-5 flex-shrink-0 text-black dark:text-neutral-100" />
-                    <div>
-                      <Label>Cloud</Label>
-                      <Description>
-                        {cloudOverriddenByEnv
-                          ? "The OLLAMA_NO_CLOUD environment variable is currently forcing cloud off."
-                          : "Enable cloud models and web search."}
-                      </Description>
-                    </div>
-                  </div>
-                  <div className="flex-shrink-0">
-                    <Switch
-                      checked={!cloudDisabled}
-                      disabled={cloudToggleDisabled}
-                      onChange={(checked) => {
-                        if (cloudOverriddenByEnv) {
-                          return;
-                        }
-                        updateCloudMutation.mutate(checked);
-                      }}
-                    />
-                  </div>
-                </div>
-              </Field>
-
              {/* Expose Ollama */}
              <Field>
                <div className="flex items-start justify-between gap-4">
@@ -528,6 +440,35 @@ export default function Settings() {
                  </div>
                </div>
              </Field>
+              {/* Airplane Mode */}
+              <Field>
+                <div className="flex items-start justify-between gap-4">
+                  <div className="flex items-start space-x-3 flex-1">
+                    <svg
+                      className="mt-1 h-5 w-5 flex-shrink-0 text-black dark:text-neutral-100"
+                      viewBox="0 0 21.5508 17.9033"
+                      fill="currentColor"
+                    >
+                      <path d="M21.5508 8.94727C21.542 7.91895 20.1445 7.17188 18.4658 7.17188L14.9238 7.17188C14.4316 7.17188 14.2471 7.09277 13.957 6.75879L8.05078 0.316406C7.86621 0.105469 7.6377 0 7.37402 0L6.35449 0C6.12598 0 5.99414 0.202148 6.1084 0.448242L9.14941 7.17188L4.68457 7.68164L3.09375 4.76367C2.97949 4.54395 2.78613 4.44727 2.49609 4.44727L2.11816 4.44727C1.88965 4.44727 1.74023 4.59668 1.74023 4.8252L1.74023 13.0693C1.74023 13.2979 1.88965 13.4385 2.11816 13.4385L2.49609 13.4385C2.78613 13.4385 2.97949 13.3418 3.09375 13.1309L4.68457 10.2129L9.14941 10.7227L6.1084 17.4463C5.99414 17.6836 6.12598 17.8945 6.35449 17.8945L7.37402 17.8945C7.6377 17.8945 7.86621 17.7803 8.05078 17.5781L13.957 11.127C14.2471 10.8018 14.4316 10.7227 14.9238 10.7227L18.4658 10.7227C20.1445 10.7227 21.542 9.9668 21.5508 8.94727Z" />
+                    </svg>
+                    <div>
+                      <Label>Airplane mode</Label>
+                      <Description>
+                        Airplane mode keeps data local, disabling cloud models
+                        and web search.
+                      </Description>
+                    </div>
+                  </div>
+                  <div className="flex-shrink-0">
+                    <Switch
+                      checked={settings.AirplaneMode}
+                      onChange={(checked) =>
+                        handleChange("AirplaneMode", checked)
+                      }
+                    />
+                  </div>
+                </div>
+              </Field>
            </div>
          </div>

--- a/app/ui/app/src/hooks/useChats.ts
+++ b/app/ui/app/src/hooks/useChats.ts
@@ -6,8 +6,8 @@ import { useSelectedModel } from "./useSelectedModel";
 import { createQueryBatcher } from "./useQueryBatcher";
 import { useRefetchModels } from "./useModels";
 import { useStreamingContext } from "@/contexts/StreamingContext";
+import { useSettings } from "./useSettings";
 import { getModelCapabilities } from "@/api";
-import { useCloudStatus } from "./useCloudStatus";

 export const useChats = () => {
  return useQuery({
@@ -116,9 +116,11 @@ export const useIsModelStale = (modelName: string) => {
 export const useShouldShowStaleDisplay = (model: Model | null) => {
  const isStale = useIsModelStale(model?.model || "");
  const { data: dismissedModels } = useDismissedStaleModels();
-  const { cloudDisabled } = useCloudStatus();
+  const {
+    settings: { airplaneMode },
+  } = useSettings();

-  if (model?.isCloud() && !cloudDisabled) {
+  if (model?.isCloud() && !airplaneMode) {
    return false;
  }

--- a/app/ui/app/src/hooks/useCloudStatus.ts
+++ b/app/ui/app/src/hooks/useCloudStatus.ts
@@ -1,20 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-import { getCloudStatus, type CloudStatusResponse } from "@/api";
-
-export function useCloudStatus() {
-  const cloudQuery = useQuery<CloudStatusResponse | null>({
-    queryKey: ["cloudStatus"],
-    queryFn: getCloudStatus,
-    retry: false,
-    staleTime: 60 * 1000,
-  });
-
-  return {
-    cloudStatus: cloudQuery.data,
-    cloudDisabled: cloudQuery.data?.disabled ?? false,
-    isKnown: cloudQuery.data !== null && cloudQuery.data !== undefined,
-    isLoading: cloudQuery.isLoading,
-    isError: cloudQuery.isError,
-    error: cloudQuery.error,
-  };
-}
--- a/app/ui/app/src/hooks/useModels.ts
+++ b/app/ui/app/src/hooks/useModels.ts
@@ -2,11 +2,11 @@ import { useQuery } from "@tanstack/react-query";
 import { Model } from "@/gotypes";
 import { getModels } from "@/api";
 import { mergeModels } from "@/utils/mergeModels";
+import { useSettings } from "./useSettings";
 import { useMemo } from "react";
-import { useCloudStatus } from "./useCloudStatus";

 export function useModels(searchQuery = "") {
-  const { cloudDisabled } = useCloudStatus();
+  const { settings } = useSettings();
  const localQuery = useQuery<Model[], Error>({
    queryKey: ["models", searchQuery],
    queryFn: () => getModels(searchQuery),
@@ -20,7 +20,7 @@ export function useModels(searchQuery = "") {
  });

  const allModels = useMemo(() => {
-    const models = mergeModels(localQuery.data || [], cloudDisabled);
+    const models = mergeModels(localQuery.data || [], settings.airplaneMode);

    if (searchQuery && searchQuery.trim()) {
      const query = searchQuery.toLowerCase().trim();
@@ -40,7 +40,7 @@ export function useModels(searchQuery = "") {
    }

    return models;
-  }, [localQuery.data, searchQuery, cloudDisabled]);
+  }, [localQuery.data, searchQuery, settings.airplaneMode]);

  return {
    ...localQuery,
--- a/app/ui/app/src/hooks/useSelectedModel.ts
+++ b/app/ui/app/src/hooks/useSelectedModel.ts
@@ -7,7 +7,6 @@ import { Model } from "@/gotypes";
 import { FEATURED_MODELS } from "@/utils/mergeModels";
 import { getTotalVRAM } from "@/utils/vram.ts";
 import { getInferenceCompute } from "@/api";
-import { useCloudStatus } from "./useCloudStatus";

 export function recommendDefaultModel(totalVRAM: number): string {
  const vram = Math.max(0, Number(totalVRAM) || 0);
@@ -23,7 +22,6 @@ export function recommendDefaultModel(totalVRAM: number): string {
 export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
  const { settings, setSettings } = useSettings();
  const { data: models = [], isLoading } = useModels(searchQuery || "");
-  const { cloudDisabled } = useCloudStatus();
  const { data: chatData, isLoading: isChatLoading } = useChat(
    currentChatId && currentChatId !== "new" ? currentChatId : "",
  );
@@ -48,11 +46,12 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
  const restoredChatRef = useRef<string | null>(null);

  const selectedModel: Model | null = useMemo(() => {
-    // If cloud is disabled and selected model ends with cloud, switch to a local default.
-    if (cloudDisabled && settings.selectedModel?.endsWith("cloud")) {
+    // if airplane mode is on and selected model ends with cloud,
+    // switch to recommended default model
+    if (settings.airplaneMode && settings.selectedModel?.endsWith("cloud")) {
      return (
        models.find((m) => m.model === recommendedModel) ||
-        models.find((m) => !m.isCloud()) ||
+        models.find((m) => m.isCloud) ||
        models.find((m) => m.digest === undefined || m.digest === "") ||
        models[0] ||
        null
@@ -69,7 +68,7 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
      "qwen3-coder:480b",
    ];
    const shouldMigrate =
-      !cloudDisabled &&
+      !settings.airplaneMode &&
      settings.turboEnabled &&
      baseModelsToMigrate.includes(settings.selectedModel);

@@ -97,18 +96,13 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
        })) ||
      null
    );
-  }, [
-    models,
-    settings.selectedModel,
-    cloudDisabled,
-    recommendedModel,
-  ]);
+  }, [models, settings.selectedModel, settings.airplaneMode, recommendedModel]);

  useEffect(() => {
    if (!selectedModel) return;

    if (
-      cloudDisabled &&
+      settings.airplaneMode &&
      settings.selectedModel?.endsWith("cloud") &&
      selectedModel.model !== settings.selectedModel
    ) {
@@ -116,17 +110,13 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
    }

    if (
-      !cloudDisabled &&
+      !settings.airplaneMode &&
      settings.turboEnabled &&
      selectedModel.model !== settings.selectedModel
    ) {
      setSettings({ SelectedModel: selectedModel.model, TurboEnabled: false });
    }
-  }, [
-    selectedModel,
-    cloudDisabled,
-    settings.selectedModel,
-  ]);
+  }, [selectedModel, settings.airplaneMode, settings.selectedModel]);

  // Set model from chat history when chat data loads
  useEffect(() => {
@@ -179,9 +169,7 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {

    const defaultModel =
      models.find((m) => m.model === recommendedModel) ||
-      (cloudDisabled
-        ? models.find((m) => !m.isCloud())
-        : models.find((m) => m.isCloud())) ||
+      models.find((m) => m.isCloud()) ||
      models.find((m) => m.digest === undefined || m.digest === "") ||
      models[0];

@@ -193,7 +181,6 @@ export function useSelectedModel(currentChatId?: string, searchQuery?: string) {
    inferenceComputes.length,
    models.length,
    settings.selectedModel,
-    cloudDisabled,
  ]);

  // Add the selected model to the models list if it's not already there
--- a/app/ui/app/src/hooks/useSettings.ts
+++ b/app/ui/app/src/hooks/useSettings.ts
@@ -9,6 +9,7 @@ interface SettingsState {
  webSearchEnabled: boolean;
  selectedModel: string;
  sidebarOpen: boolean;
+  airplaneMode: boolean;
  thinkEnabled: boolean;
  thinkLevel: string;
 }
@@ -50,6 +51,7 @@ export function useSettings() {
      thinkLevel: settingsData?.settings?.ThinkLevel ?? "none",
      selectedModel: settingsData?.settings?.SelectedModel ?? "",
      sidebarOpen: settingsData?.settings?.SidebarOpen ?? false,
+      airplaneMode: settingsData?.settings?.AirplaneMode ?? false,
    }),
    [settingsData?.settings],
  );
--- a/app/ui/app/src/routes/__root.tsx
+++ b/app/ui/app/src/routes/__root.tsx
@@ -2,7 +2,6 @@ import type { QueryClient } from "@tanstack/react-query";
 import { createRootRouteWithContext, Outlet } from "@tanstack/react-router";
 import { getSettings } from "@/api";
 import { useQuery } from "@tanstack/react-query";
-import { useCloudStatus } from "@/hooks/useCloudStatus";

 function RootComponent() {
  // This hook ensures settings are fetched on app startup
@@ -10,8 +9,6 @@ function RootComponent() {
    queryKey: ["settings"],
    queryFn: getSettings,
  });
-  // Fetch cloud status on startup (best-effort)
-  useCloudStatus();

  return (
    <div>
--- a/app/ui/app/src/utils/mergeModels.test.ts
+++ b/app/ui/app/src/utils/mergeModels.test.ts
@@ -41,14 +41,14 @@ describe("Model merging logic", () => {
    expect(merged.length).toBe(FEATURED_MODELS.length + 2);
  });

-  it("should hide cloud models when cloud is disabled", () => {
+  it("should hide cloud models in airplane mode", () => {
    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
+    const merged = mergeModels(localModels, true); // airplane mode = true

    // No cloud models should be present
    const cloudModels = merged.filter((m) => m.isCloud());
--- a/app/ui/app/src/utils/mergeModels.ts
+++ b/app/ui/app/src/utils/mergeModels.ts
@@ -32,7 +32,7 @@ function alphabeticalSort(a: Model, b: Model): number {
 //Merges models, sorting cloud models first, then other models
 export function mergeModels(
  localModels: Model[],
-  hideCloudModels: boolean = false,
+  airplaneMode: boolean = false,
 ): Model[] {
  const allModels = (localModels || []).map((model) => model);

@@ -95,7 +95,7 @@ export function mergeModels(

  remainingModels.sort(alphabeticalSort);

-  return hideCloudModels
+  return airplaneMode
    ? [...featuredModels, ...remainingModels]
    : [...cloudModels, ...featuredModels, ...remainingModels];
 }
--- a/app/ui/ui.go
+++ b/app/ui/ui.go
@@ -284,15 +284,12 @@ func (s *Server) Handler() http.Handler {
 	mux.Handle("POST /api/v1/model/upstream", handle(s.modelUpstream))
 	mux.Handle("GET /api/v1/settings", handle(s.getSettings))
 	mux.Handle("POST /api/v1/settings", handle(s.settings))
-	mux.Handle("GET /api/v1/cloud", handle(s.getCloudSetting))
-	mux.Handle("POST /api/v1/cloud", handle(s.cloudSetting))

 	// Ollama proxy endpoints
 	ollamaProxy := s.ollamaProxy()
 	mux.Handle("GET /api/tags", ollamaProxy)
 	mux.Handle("POST /api/show", ollamaProxy)
 	mux.Handle("GET /api/version", ollamaProxy)
-	mux.Handle("GET /api/status", ollamaProxy)
 	mux.Handle("HEAD /api/version", ollamaProxy)
 	mux.Handle("POST /api/me", ollamaProxy)
 	mux.Handle("POST /api/signout", ollamaProxy)
@@ -1463,40 +1460,6 @@ func (s *Server) settings(w http.ResponseWriter, r *http.Request) error {
 	})
 }

-func (s *Server) cloudSetting(w http.ResponseWriter, r *http.Request) error {
-	var req struct {
-		Enabled bool `json:"enabled"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		return fmt.Errorf("invalid request body: %w", err)
-	}
-
-	if err := s.Store.SetCloudEnabled(req.Enabled); err != nil {
-		return fmt.Errorf("failed to persist cloud setting: %w", err)
-	}
-
-	s.Restart()
-
-	return s.writeCloudStatus(w)
-}
-
-func (s *Server) getCloudSetting(w http.ResponseWriter, r *http.Request) error {
-	return s.writeCloudStatus(w)
-}
-
-func (s *Server) writeCloudStatus(w http.ResponseWriter) error {
-	disabled, source, err := s.Store.CloudStatus()
-	if err != nil {
-		return fmt.Errorf("failed to load cloud status: %w", err)
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	return json.NewEncoder(w).Encode(map[string]any{
-		"disabled": disabled,
-		"source":   source,
-	})
-}
-
 func (s *Server) getInferenceCompute(w http.ResponseWriter, r *http.Request) error {
 	ctx, cancel := context.WithTimeout(r.Context(), 500*time.Millisecond)
 	defer cancel()
--- a/app/ui/ui_test.go
+++ b/app/ui/ui_test.go
@@ -115,107 +115,6 @@ func TestHandlePostApiSettings(t *testing.T) {
 	}
 }

-func TestHandlePostApiCloudSetting(t *testing.T) {
-	tmpHome := t.TempDir()
-	t.Setenv("HOME", tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	restartCount := 0
-	server := &Server{
-		Store: testStore,
-		Restart: func() {
-			restartCount++
-		},
-	}
-
-	for _, tc := range []struct {
-		name        string
-		body        string
-		wantEnabled bool
-	}{
-		{name: "disable cloud", body: `{"enabled": false}`, wantEnabled: false},
-		{name: "enable cloud", body: `{"enabled": true}`, wantEnabled: true},
-	} {
-		t.Run(tc.name, func(t *testing.T) {
-			req := httptest.NewRequest("POST", "/api/v1/cloud", bytes.NewBufferString(tc.body))
-			req.Header.Set("Content-Type", "application/json")
-			rr := httptest.NewRecorder()
-
-			if err := server.cloudSetting(rr, req); err != nil {
-				t.Fatalf("cloudSetting() error = %v", err)
-			}
-			if rr.Code != http.StatusOK {
-				t.Fatalf("cloudSetting() status = %d, want %d", rr.Code, http.StatusOK)
-			}
-
-			var got map[string]any
-			if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil {
-				t.Fatalf("cloudSetting() invalid response JSON: %v", err)
-			}
-			if got["disabled"] != !tc.wantEnabled {
-				t.Fatalf("response disabled = %v, want %v", got["disabled"], !tc.wantEnabled)
-			}
-
-			disabled, err := testStore.CloudDisabled()
-			if err != nil {
-				t.Fatalf("CloudDisabled() error = %v", err)
-			}
-			if gotEnabled := !disabled; gotEnabled != tc.wantEnabled {
-				t.Fatalf("cloud enabled = %v, want %v", gotEnabled, tc.wantEnabled)
-			}
-		})
-	}
-
-	if restartCount != 2 {
-		t.Fatalf("Restart called %d times, want 2", restartCount)
-	}
-}
-
-func TestHandleGetApiCloudSetting(t *testing.T) {
-	tmpHome := t.TempDir()
-	t.Setenv("HOME", tmpHome)
-	t.Setenv("OLLAMA_NO_CLOUD", "")
-
-	testStore := &store.Store{
-		DBPath: filepath.Join(t.TempDir(), "db.sqlite"),
-	}
-	defer testStore.Close()
-
-	if err := testStore.SetCloudEnabled(false); err != nil {
-		t.Fatalf("SetCloudEnabled(false) error = %v", err)
-	}
-
-	server := &Server{
-		Store:   testStore,
-		Restart: func() {},
-	}
-
-	req := httptest.NewRequest("GET", "/api/v1/cloud", nil)
-	rr := httptest.NewRecorder()
-	if err := server.getCloudSetting(rr, req); err != nil {
-		t.Fatalf("getCloudSetting() error = %v", err)
-	}
-	if rr.Code != http.StatusOK {
-		t.Fatalf("getCloudSetting() status = %d, want %d", rr.Code, http.StatusOK)
-	}
-
-	var got map[string]any
-	if err := json.Unmarshal(rr.Body.Bytes(), &got); err != nil {
-		t.Fatalf("getCloudSetting() invalid response JSON: %v", err)
-	}
-	if got["disabled"] != true {
-		t.Fatalf("response disabled = %v, want true", got["disabled"])
-	}
-	if got["source"] != "config" {
-		t.Fatalf("response source = %v, want config", got["source"])
-	}
-}
-
 func TestAuthenticationMiddleware(t *testing.T) {
 	tests := []struct {
 		name         string
--- a/cmd/cmd.go
+++ b/cmd/cmd.go
@@ -55,43 +55,6 @@ import (
 	"github.com/ollama/ollama/x/imagegen"
 )

-func init() {
-	// Override default selectors to use Bubbletea TUI instead of raw terminal I/O.
-	config.DefaultSingleSelector = func(title string, items []config.ModelItem) (string, error) {
-		tuiItems := tui.ReorderItems(tui.ConvertItems(items))
-		result, err := tui.SelectSingle(title, tuiItems)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
-		}
-		return result, err
-	}
-
-	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
-	}
-
-	config.DefaultSignIn = func(modelName, signInURL string) (string, error) {
-		userName, err := tui.RunSignIn(modelName, signInURL)
-		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
-		}
-		return userName, err
-	}
-
-	config.DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		ok, err := tui.RunConfirm(prompt)
-		if errors.Is(err, tui.ErrCancelled) {
-			return false, config.ErrCancelled
-		}
-		return ok, err
-	}
-}
-
 const ConnectInstructions = "If your browser did not open, navigate to:\n    %s\n\n"

 // ensureThinkingSupport emits a warning if the model does not advertise thinking support
@@ -1885,15 +1848,18 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		return
 	}

+	// errSelectionCancelled is returned when user cancels model selection
+	errSelectionCancelled := errors.New("cancelled")
+
 	// Selector adapters for tui
 	singleSelector := func(title string, items []config.ModelItem) (string, error) {
 		tuiItems := make([]tui.SelectItem, len(items))
 		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
+			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description}
 		}
 		result, err := tui.SelectSingle(title, tuiItems)
 		if errors.Is(err, tui.ErrCancelled) {
-			return "", config.ErrCancelled
+			return "", errSelectionCancelled
 		}
 		return result, err
 	}
@@ -1901,11 +1867,11 @@ func runInteractiveTUI(cmd *cobra.Command) {
 	multiSelector := func(title string, items []config.ModelItem, preChecked []string) ([]string, error) {
 		tuiItems := make([]tui.SelectItem, len(items))
 		for i, item := range items {
-			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
+			tuiItems[i] = tui.SelectItem{Name: item.Name, Description: item.Description}
 		}
 		result, err := tui.SelectMultiple(title, tuiItems, preChecked)
 		if errors.Is(err, tui.ErrCancelled) {
-			return nil, config.ErrCancelled
+			return nil, errSelectionCancelled
 		}
 		return result, err
 	}
@@ -1918,18 +1884,6 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		}

 		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,
@@ -1949,9 +1903,9 @@ func runInteractiveTUI(cmd *cobra.Command) {
 		launchIntegration := func(name string) bool {
 			// 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) {
+			if configuredModel == "" || !config.ModelExists(cmd.Context(), configuredModel) {
 				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), name, singleSelector, multiSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					return false // Return to main menu
 				}
 				if err != nil {
@@ -1971,11 +1925,13 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			return
 		case tui.SelectionRunModel:
 			_ = config.SetLastSelection("run")
-			if modelName := config.LastModel(); modelName != "" && !config.IsCloudModelDisabled(cmd.Context(), modelName) {
+			// Run last model directly if configured and still exists
+			if modelName := config.LastModel(); modelName != "" && config.ModelExists(cmd.Context(), modelName) {
 				runModel(modelName)
 			} else {
+				// No last model or model no longer exists, show picker
 				modelName, err := config.SelectModelWithSelector(cmd.Context(), singleSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -1991,7 +1947,7 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			if modelName == "" {
 				var err error
 				modelName, err = config.SelectModelWithSelector(cmd.Context(), singleSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -1999,9 +1955,6 @@ func runInteractiveTUI(cmd *cobra.Command) {
 					continue
 				}
 			}
-			if config.IsCloudModelDisabled(cmd.Context(), modelName) {
-				continue // Return to main menu
-			}
 			runModel(modelName)
 		case tui.SelectionIntegration:
 			_ = config.SetLastSelection(result.Integration)
@@ -2010,32 +1963,10 @@ func runInteractiveTUI(cmd *cobra.Command) {
 			}
 		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 {
+			// Use model from modal if selected, otherwise show picker
+			if result.Model != "" {
+				// Model already selected from modal - save and launch
+				if err := config.SaveIntegrationModel(result.Integration, result.Model); err != nil {
 					fmt.Fprintf(os.Stderr, "Error saving config: %v\n", err)
 					continue
 				}
@@ -2044,7 +1975,7 @@ func runInteractiveTUI(cmd *cobra.Command) {
 				}
 			} else {
 				err := config.ConfigureIntegrationWithSelectors(cmd.Context(), result.Integration, singleSelector, multiSelector)
-				if errors.Is(err, config.ErrCancelled) {
+				if errors.Is(err, errSelectionCancelled) {
 					continue // Return to main menu
 				}
 				if err != nil {
@@ -2279,7 +2210,7 @@ func NewCLI() *cobra.Command {
 		switch cmd {
 		case runCmd:
 			imagegen.AppendFlagsDocs(cmd)
-			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_EDITOR"], envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
+			appendEnvDocs(cmd, []envconfig.EnvVar{envVars["OLLAMA_HOST"], envVars["OLLAMA_NOHISTORY"]})
 		case serveCmd:
 			appendEnvDocs(cmd, []envconfig.EnvVar{
 				envVars["OLLAMA_DEBUG"],
@@ -2290,7 +2221,6 @@ func NewCLI() *cobra.Command {
 				envVars["OLLAMA_MAX_QUEUE"],
 				envVars["OLLAMA_MODELS"],
 				envVars["OLLAMA_NUM_PARALLEL"],
-				envVars["OLLAMA_NO_CLOUD"],
 				envVars["OLLAMA_NOPRUNE"],
 				envVars["OLLAMA_ORIGINS"],
 				envVars["OLLAMA_SCHED_SPREAD"],
--- a/cmd/config/claude.go
+++ b/cmd/config/claude.go
@@ -126,7 +126,8 @@ func (c *Claude) ConfigureAliases(ctx context.Context, model string, existingAli
 	fmt.Fprintf(os.Stderr, "\n%sModel Configuration%s\n\n", ansiBold, ansiReset)

 	if aliases["primary"] == "" || force {
-		primary, err := DefaultSingleSelector("Select model:", items)
+		primary, err := selectPrompt("Select model:", items)
+		fmt.Fprintf(os.Stderr, "\033[3A\033[J")
 		if err != nil {
 			return nil, false, err
 		}
--- a/cmd/config/claude_test.go
+++ b/cmd/config/claude_test.go
@@ -140,7 +140,7 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)

-		SaveIntegration("claude", []string{"qwen3:8b"})
+		saveIntegration("claude", []string{"qwen3:8b"})
 		saveAliases("claude", map[string]string{"primary": "qwen3:8b"})

 		got := envMap(c.modelEnvVars("qwen3:8b"))
@@ -162,7 +162,7 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)

-		SaveIntegration("claude", []string{"llama3.2:70b"})
+		saveIntegration("claude", []string{"llama3.2:70b"})
 		saveAliases("claude", map[string]string{
 			"primary": "llama3.2:70b",
 			"fast":    "llama3.2:8b",
@@ -187,7 +187,7 @@ func TestClaudeModelEnvVars(t *testing.T) {
 		tmpDir := t.TempDir()
 		setTestHome(t, tmpDir)

-		SaveIntegration("claude", []string{"saved-model"})
+		saveIntegration("claude", []string{"saved-model"})
 		saveAliases("claude", map[string]string{"primary": "saved-model"})

 		got := envMap(c.modelEnvVars("different-model"))
--- a/cmd/config/config.go
+++ b/cmd/config/config.go
@@ -56,8 +56,8 @@ func migrateConfig() (bool, error) {
 		return false, err
 	}

-	// Ignore legacy files with invalid JSON and continue startup.
-	if !json.Valid(oldData) {
+	var js json.RawMessage
+	if err := json.Unmarshal(oldData, &js); err != nil {
 		return false, nil
 	}

@@ -126,7 +126,7 @@ func save(cfg *config) error {
 	return writeWithBackup(path, data)
 }

-func SaveIntegration(appName string, models []string) error {
+func saveIntegration(appName string, models []string) error {
 	if appName == "" {
 		return errors.New("app name cannot be empty")
 	}
@@ -160,15 +160,6 @@ func IntegrationModel(appName string) string {
 	return ic.Models[0]
 }

-// IntegrationModels returns all configured models for an integration, or nil.
-func IntegrationModels(appName string) []string {
-	ic, err := loadIntegration(appName)
-	if err != nil || len(ic.Models) == 0 {
-		return nil
-	}
-	return ic.Models
-}
-
 // LastModel returns the last model that was run, or empty string if none.
 func LastModel() string {
 	cfg, err := load()
--- a/cmd/config/config_cloud_test.go
+++ b/cmd/config/config_cloud_test.go
@@ -85,7 +85,7 @@ func TestSaveAliases_PreservesModels(t *testing.T) {
 	setTestHome(t, tmpDir)

 	// First save integration with models
-	if err := SaveIntegration("claude", []string{"model1", "model2"}); err != nil {
+	if err := saveIntegration("claude", []string{"model1", "model2"}); err != nil {
 		t.Fatalf("failed to save integration: %v", err)
 	}

@@ -604,7 +604,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		}

 		// Save integration with same model (this is the pattern we use)
-		if err := SaveIntegration("claude", []string{"model-a"}); err != nil {
+		if err := saveIntegration("claude", []string{"model-a"}); err != nil {
 			t.Fatal(err)
 		}

@@ -619,7 +619,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Simulate out-of-sync state (like manual edit or bug)
-		if err := SaveIntegration("claude", []string{"old-model"}); err != nil {
+		if err := saveIntegration("claude", []string{"old-model"}); err != nil {
 			t.Fatal(err)
 		}
 		if err := saveAliases("claude", map[string]string{"primary": "new-model"}); err != nil {
@@ -634,7 +634,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		}

 		// The fix: when updating aliases, also update models
-		if err := SaveIntegration("claude", []string{loaded.Aliases["primary"]}); err != nil {
+		if err := saveIntegration("claude", []string{loaded.Aliases["primary"]}); err != nil {
 			t.Fatal(err)
 		}

@@ -650,7 +650,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		setTestHome(t, tmpDir)

 		// Initial state
-		if err := SaveIntegration("claude", []string{"initial-model"}); err != nil {
+		if err := saveIntegration("claude", []string{"initial-model"}); err != nil {
 			t.Fatal(err)
 		}
 		if err := saveAliases("claude", map[string]string{"primary": "initial-model"}); err != nil {
@@ -662,7 +662,7 @@ func TestModelsAndAliasesMustStayInSync(t *testing.T) {
 		if err := saveAliases("claude", newAliases); err != nil {
 			t.Fatal(err)
 		}
-		if err := SaveIntegration("claude", []string{newAliases["primary"]}); err != nil {
+		if err := saveIntegration("claude", []string{newAliases["primary"]}); err != nil {
 			t.Fatal(err)
 		}

--- a/cmd/config/config_test.go
+++ b/cmd/config/config_test.go
@@ -27,7 +27,7 @@ func TestIntegrationConfig(t *testing.T) {

 	t.Run("save and load round-trip", func(t *testing.T) {
 		models := []string{"llama3.2", "mistral", "qwen2.5"}
-		if err := SaveIntegration("claude", models); err != nil {
+		if err := saveIntegration("claude", models); err != nil {
 			t.Fatal(err)
 		}

@@ -48,7 +48,7 @@ func TestIntegrationConfig(t *testing.T) {

 	t.Run("save and load aliases", func(t *testing.T) {
 		models := []string{"llama3.2"}
-		if err := SaveIntegration("claude", models); err != nil {
+		if err := saveIntegration("claude", models); err != nil {
 			t.Fatal(err)
 		}
 		aliases := map[string]string{
@@ -74,14 +74,14 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("saveIntegration preserves aliases", func(t *testing.T) {
-		if err := SaveIntegration("claude", []string{"model-a"}); err != nil {
+		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 {
 			t.Fatal(err)
 		}

-		if err := SaveIntegration("claude", []string{"model-b"}); err != nil {
+		if err := saveIntegration("claude", []string{"model-b"}); err != nil {
 			t.Fatal(err)
 		}
 		config, err := loadIntegration("claude")
@@ -94,7 +94,7 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("defaultModel returns first model", func(t *testing.T) {
-		SaveIntegration("codex", []string{"model-a", "model-b"})
+		saveIntegration("codex", []string{"model-a", "model-b"})

 		config, _ := loadIntegration("codex")
 		defaultModel := ""
@@ -118,7 +118,7 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("app name is case-insensitive", func(t *testing.T) {
-		SaveIntegration("Claude", []string{"model-x"})
+		saveIntegration("Claude", []string{"model-x"})

 		config, err := loadIntegration("claude")
 		if err != nil {
@@ -134,8 +134,8 @@ func TestIntegrationConfig(t *testing.T) {
 	})

 	t.Run("multiple integrations in single file", func(t *testing.T) {
-		SaveIntegration("app1", []string{"model-1"})
-		SaveIntegration("app2", []string{"model-2"})
+		saveIntegration("app1", []string{"model-1"})
+		saveIntegration("app2", []string{"model-2"})

 		config1, _ := loadIntegration("app1")
 		config2, _ := loadIntegration("app2")
@@ -172,8 +172,8 @@ func TestListIntegrations(t *testing.T) {
 	})

 	t.Run("returns all saved integrations", func(t *testing.T) {
-		SaveIntegration("claude", []string{"model-1"})
-		SaveIntegration("droid", []string{"model-2"})
+		saveIntegration("claude", []string{"model-1"})
+		saveIntegration("droid", []string{"model-2"})

 		configs, err := listIntegrations()
 		if err != nil {
@@ -261,7 +261,7 @@ func TestSaveIntegration_NilModels(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	if err := SaveIntegration("test", nil); err != nil {
+	if err := saveIntegration("test", nil); err != nil {
 		t.Fatalf("saveIntegration with nil models failed: %v", err)
 	}

@@ -281,7 +281,7 @@ func TestSaveIntegration_EmptyAppName(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

-	err := SaveIntegration("", []string{"model"})
+	err := saveIntegration("", []string{"model"})
 	if err == nil {
 		t.Error("expected error for empty app name, got nil")
 	}
@@ -511,7 +511,7 @@ func TestMigrateConfig(t *testing.T) {
 		os.WriteFile(filepath.Join(legacyDir, "config.json"), []byte(`{"integrations":{"claude":{"models":["llama3.2"]}}}`), 0o644)

 		// load triggers migration, then save should write to new path
-		if err := SaveIntegration("codex", []string{"qwen2.5"}); err != nil {
+		if err := saveIntegration("codex", []string{"qwen2.5"}); err != nil {
 			t.Fatal(err)
 		}

--- a/cmd/config/droid.go
+++ b/cmd/config/droid.go
@@ -3,7 +3,6 @@ package config
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -52,16 +51,6 @@ func (d *Droid) Run(model string, args []string) error {
 	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)
 	}
--- a/cmd/config/integrations.go
+++ b/cmd/config/integrations.go
@@ -4,17 +4,18 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io"
 	"maps"
 	"net/http"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"runtime"
 	"slices"
 	"strings"
 	"time"

 	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
 	"github.com/ollama/ollama/progress"
 	"github.com/spf13/cobra"
 )
@@ -65,104 +66,30 @@ var integrations = map[string]Runner{
 // recommendedModels are shown when the user has no models or as suggestions.
 // Order matters: local models first, then cloud models.
 var recommendedModels = []ModelItem{
-	{Name: "minimax-m2.5:cloud", Description: "Fast, efficient coding and real-world productivity", Recommended: true},
-	{Name: "glm-5:cloud", Description: "Reasoning and code generation", Recommended: true},
-	{Name: "kimi-k2.5:cloud", Description: "Multimodal reasoning with subagents", Recommended: true},
-	{Name: "glm-4.7-flash", Description: "Reasoning and code generation locally", Recommended: true},
-	{Name: "qwen3:8b", Description: "Efficient all-purpose assistant", Recommended: true},
-}
-
-// cloudModelLimits maps cloud model base names to their token limits.
-// TODO(parthsareen): grab context/output limits from model info instead of hardcoding
-var cloudModelLimits = map[string]cloudModelLimit{
-	"minimax-m2.5":        {Context: 204_800, Output: 128_000},
-	"cogito-2.1:671b":     {Context: 163_840, Output: 65_536},
-	"deepseek-v3.1:671b":  {Context: 163_840, Output: 163_840},
-	"deepseek-v3.2":       {Context: 163_840, Output: 65_536},
-	"glm-4.6":             {Context: 202_752, Output: 131_072},
-	"glm-4.7":             {Context: 202_752, Output: 131_072},
-	"gpt-oss:120b":        {Context: 131_072, Output: 131_072},
-	"gpt-oss:20b":         {Context: 131_072, Output: 131_072},
-	"kimi-k2:1t":          {Context: 262_144, Output: 262_144},
-	"kimi-k2.5":           {Context: 262_144, Output: 262_144},
-	"kimi-k2-thinking":    {Context: 262_144, Output: 262_144},
-	"nemotron-3-nano:30b": {Context: 1_048_576, Output: 131_072},
-	"qwen3-coder:480b":    {Context: 262_144, Output: 65_536},
-	"qwen3-coder-next":    {Context: 262_144, Output: 32_768},
-	"qwen3-next:80b":      {Context: 262_144, Output: 32_768},
-}
-
-// recommendedVRAM maps local recommended models to their approximate VRAM requirement.
-var recommendedVRAM = map[string]string{
-	"glm-4.7-flash": "~25GB",
-	"qwen3:8b":      "~11GB",
+	{Name: "glm-4.7-flash", Description: "Recommended (requires ~25GB VRAM)"},
+	{Name: "qwen3:8b", Description: "Recommended (requires ~11GB VRAM)"},
+	{Name: "glm-4.7:cloud", Description: "Recommended"},
+	{Name: "kimi-k2.5:cloud", Description: "Recommended"},
 }

 // integrationAliases are hidden from the interactive selector but work as CLI arguments.
 var integrationAliases = map[string]bool{
 	"clawdbot": true,
 	"moltbot":  true,
-	"pi":       true,
 }

-// integrationInstallHints maps integration names to install URLs.
-var integrationInstallHints = map[string]string{
-	"claude":   "https://code.claude.com/docs/en/quickstart",
-	"openclaw": "https://docs.openclaw.ai",
-	"codex":    "https://developers.openai.com/codex/cli/",
-	"droid":    "https://docs.factory.ai/cli/getting-started/quickstart",
-	"opencode": "https://opencode.ai",
+// integrationInstallURLs maps integration names to their install script URLs.
+var integrationInstallURLs = map[string]string{
+	"claude":   "https://claude.ai/install.sh",
+	"openclaw": "https://openclaw.ai/install.sh",
+	"droid":    "https://app.factory.ai/cli",
+	"opencode": "https://opencode.ai/install",
 }

-// hyperlink wraps text in an OSC 8 terminal hyperlink so it is cmd+clickable.
-func hyperlink(url, text string) string {
-	return fmt.Sprintf("\033]8;;%s\033\\%s\033]8;;\033\\", url, text)
-}
-
-// IntegrationInfo contains display information about a registered integration.
-type IntegrationInfo struct {
-	Name        string // registry key, e.g. "claude"
-	DisplayName string // human-readable, e.g. "Claude Code"
-	Description string // short description, e.g. "Anthropic's agentic coding tool"
-}
-
-// integrationDescriptions maps integration names to short descriptions.
-var integrationDescriptions = map[string]string{
-	"claude":   "Anthropic's coding tool with subagents",
-	"codex":    "OpenAI's open-source coding agent",
-	"openclaw": "Personal AI with 100+ skills",
-	"droid":    "Factory's coding agent across terminal and IDEs",
-	"opencode": "Anomaly's open-source coding agent",
-}
-
-// ListIntegrationInfos returns all non-alias registered integrations, sorted by name.
-func ListIntegrationInfos() []IntegrationInfo {
-	var result []IntegrationInfo
-	for name, r := range integrations {
-		if integrationAliases[name] {
-			continue
-		}
-		result = append(result, IntegrationInfo{
-			Name:        name,
-			DisplayName: r.String(),
-			Description: integrationDescriptions[name],
-		})
-	}
-	slices.SortFunc(result, func(a, b IntegrationInfo) int {
-		return strings.Compare(a.Name, b.Name)
-	})
-	return result
-}
-
-// IntegrationInstallHint returns a user-friendly install hint for the given integration,
-// or an empty string if none is available. The URL is wrapped in an OSC 8 hyperlink
-// so it is cmd+clickable in supported terminals.
-func IntegrationInstallHint(name string) string {
-	url := integrationInstallHints[name]
-	if url == "" {
-		return ""
-	}
-	return "Install from " + hyperlink(url, url)
+// CanInstallIntegration returns true if we have an install script for this integration.
+func CanInstallIntegration(name string) bool {
+	_, ok := integrationInstallURLs[name]
+	return ok
 }

 // IsIntegrationInstalled checks if an integration binary is installed.
@@ -194,15 +121,48 @@ func IsIntegrationInstalled(name string) bool {
 	}
 }

-// IsEditorIntegration returns true if the named integration uses multi-model
-// selection (implements the Editor interface).
-func IsEditorIntegration(name string) bool {
-	r, ok := integrations[strings.ToLower(name)]
+// InstallIntegration downloads and runs the install script for an integration.
+func InstallIntegration(name string) error {
+	url, ok := integrationInstallURLs[name]
 	if !ok {
-		return false
+		return fmt.Errorf("no install script available for %s", name)
 	}
-	_, isEditor := r.(Editor)
-	return isEditor
+
+	// Download the install script
+	resp, err := http.Get(url)
+	if err != nil {
+		return fmt.Errorf("failed to download install script: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("failed to download install script: HTTP %d", resp.StatusCode)
+	}
+
+	script, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("failed to read install script: %w", err)
+	}
+
+	// Create a temporary file for the script
+	tmpDir := os.TempDir()
+	scriptPath := filepath.Join(tmpDir, fmt.Sprintf("install-%s.sh", name))
+	if err := os.WriteFile(scriptPath, script, 0o700); err != nil {
+		return fmt.Errorf("failed to write install script: %w", err)
+	}
+	defer os.Remove(scriptPath)
+
+	// Execute the script with bash
+	cmd := exec.Command("bash", scriptPath)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+
+	if err := cmd.Run(); err != nil {
+		return fmt.Errorf("install script failed: %w", err)
+	}
+
+	return nil
 }

 // SelectModel lets the user select a model to run.
@@ -210,7 +170,6 @@ func IsEditorIntegration(name string) bool {
 type ModelItem struct {
 	Name        string
 	Description string
-	Recommended bool
 }

 // SingleSelector is a function type for single item selection.
@@ -236,11 +195,6 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri
 		existing = append(existing, modelInfo{Name: m.Name, Remote: m.RemoteModel != ""})
 	}

-	cloudDisabled, _ := cloudStatusDisabled(ctx, client)
-	if cloudDisabled {
-		existing = filterCloudModels(existing)
-	}
-
 	lastModel := LastModel()
 	var preChecked []string
 	if lastModel != "" {
@@ -249,14 +203,31 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri

 	items, _, existingModels, cloudModels := buildModelList(existing, preChecked, lastModel)

-	if cloudDisabled {
-		items = filterCloudItems(items)
-	}
-
 	if len(items) == 0 {
 		return "", fmt.Errorf("no models available, run 'ollama pull <model>' first")
 	}

+	// Sort with last model first, then existing models, then recommendations
+	slices.SortStableFunc(items, func(a, b ModelItem) int {
+		aIsLast := a.Name == lastModel
+		bIsLast := b.Name == lastModel
+		if aIsLast != bIsLast {
+			if aIsLast {
+				return -1
+			}
+			return 1
+		}
+		aExists := existingModels[a.Name]
+		bExists := existingModels[b.Name]
+		if aExists != bExists {
+			if aExists {
+				return -1
+			}
+			return 1
+		}
+		return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+	})
+
 	selected, err := selector("Select model to run:", items)
 	if err != nil {
 		return "", err
@@ -264,22 +235,15 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri

 	// If the selected model isn't installed, pull it first
 	if !existingModels[selected] {
-		if cloudModels[selected] {
-			// Cloud models only pull a small manifest; no confirmation needed
-			if err := pullModel(ctx, client, selected); err != nil {
-				return "", fmt.Errorf("failed to pull %s: %w", selected, err)
-			}
-		} else {
-			msg := fmt.Sprintf("Download %s?", selected)
-			if ok, err := confirmPrompt(msg); err != nil {
-				return "", err
-			} else if !ok {
-				return "", errCancelled
-			}
-			fmt.Fprintf(os.Stderr, "\n")
-			if err := pullModel(ctx, client, selected); err != nil {
-				return "", fmt.Errorf("failed to pull %s: %w", selected, err)
-			}
+		msg := fmt.Sprintf("Download %s?", selected)
+		if ok, err := confirmPrompt(msg); err != nil {
+			return "", err
+		} else if !ok {
+			return "", errCancelled
+		}
+		fmt.Fprintf(os.Stderr, "\n")
+		if err := pullModel(ctx, client, selected); err != nil {
+			return "", fmt.Errorf("failed to pull %s: %w", selected, err)
 		}
 	}

@@ -345,30 +309,32 @@ func SelectModelWithSelector(ctx context.Context, selector SingleSelector) (stri
 }

 func SelectModel(ctx context.Context) (string, error) {
-	return SelectModelWithSelector(ctx, DefaultSingleSelector)
+	return SelectModelWithSelector(ctx, defaultSingleSelector)
 }

-// DefaultSingleSelector is the default single-select implementation.
-var DefaultSingleSelector SingleSelector
+func defaultSingleSelector(title string, items []ModelItem) (string, error) {
+	selectItems := make([]selectItem, len(items))
+	for i, item := range items {
+		selectItems[i] = selectItem(item)
+	}
+	return selectPrompt(title, selectItems)
+}

-// DefaultMultiSelector is the default multi-select implementation.
-var DefaultMultiSelector MultiSelector
-
-// DefaultSignIn provides a TUI-based sign-in flow.
-// When set, ensureAuth uses it instead of plain text prompts.
-// Returns the signed-in username or an error.
-var DefaultSignIn func(modelName, signInURL string) (string, error)
+func defaultMultiSelector(title string, items []ModelItem, preChecked []string) ([]string, error) {
+	selectItems := make([]selectItem, len(items))
+	for i, item := range items {
+		selectItems[i] = selectItem(item)
+	}
+	return multiSelectPrompt(title, selectItems, preChecked)
+}

 func selectIntegration() (string, error) {
-	if DefaultSingleSelector == nil {
-		return "", fmt.Errorf("no selector configured")
-	}
 	if len(integrations) == 0 {
 		return "", fmt.Errorf("no integrations available")
 	}

 	names := slices.Sorted(maps.Keys(integrations))
-	var items []ModelItem
+	var items []selectItem
 	for _, name := range names {
 		if integrationAliases[name] {
 			continue
@@ -378,10 +344,10 @@ func selectIntegration() (string, error) {
 		if conn, err := loadIntegration(name); err == nil && len(conn.Models) > 0 {
 			description = fmt.Sprintf("%s (%s)", r.String(), conn.Models[0])
 		}
-		items = append(items, ModelItem{Name: name, Description: description})
+		items = append(items, selectItem{Name: name, Description: description})
 	}

-	return DefaultSingleSelector("Select integration:", items)
+	return selectPrompt("Select integration:", items)
 }

 // selectModelsWithSelectors lets the user select models for an integration using provided selectors.
@@ -406,11 +372,6 @@ func selectModelsWithSelectors(ctx context.Context, name, current string, single
 		existing = append(existing, modelInfo{Name: m.Name, Remote: m.RemoteModel != ""})
 	}

-	cloudDisabled, _ := cloudStatusDisabled(ctx, client)
-	if cloudDisabled {
-		existing = filterCloudModels(existing)
-	}
-
 	var preChecked []string
 	if saved, err := loadIntegration(name); err == nil {
 		preChecked = saved.Models
@@ -420,10 +381,6 @@ func selectModelsWithSelectors(ctx context.Context, name, current string, single

 	items, preChecked, existingModels, cloudModels := buildModelList(existing, preChecked, current)

-	if cloudDisabled {
-		items = filterCloudItems(items)
-	}
-
 	if len(items) == 0 {
 		return nil, fmt.Errorf("no models available")
 	}
@@ -491,17 +448,11 @@ func pullIfNeeded(ctx context.Context, client *api.Client, existingModels map[st
 	return nil
 }

-// TODO(parthsareen): pull this out to tui package
-// ShowOrPull checks if a model exists via client.Show and offers to pull it if not found.
-func ShowOrPull(ctx context.Context, client *api.Client, model string) error {
+// showOrPull checks if a model exists via client.Show and offers to pull it if not found.
+func showOrPull(ctx context.Context, client *api.Client, model string) error {
 	if _, err := client.Show(ctx, &api.ShowRequest{Model: model}); err == nil {
 		return nil
 	}
-	// Cloud models only pull a small manifest; skip the download confirmation
-	// TODO(parthsareen): consolidate with cloud config changes
-	if strings.HasSuffix(model, "cloud") {
-		return pullModel(ctx, client, model)
-	}
 	if ok, err := confirmPrompt(fmt.Sprintf("Download %s?", model)); err != nil {
 		return err
 	} else if !ok {
@@ -511,7 +462,7 @@ func ShowOrPull(ctx context.Context, client *api.Client, model string) error {
 	return pullModel(ctx, client, model)
 }

-func listModels(ctx context.Context) ([]ModelItem, map[string]bool, map[string]bool, *api.Client, error) {
+func listModels(ctx context.Context) ([]selectItem, map[string]bool, map[string]bool, *api.Client, error) {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
 		return nil, nil, nil, nil, err
@@ -530,33 +481,18 @@ func listModels(ctx context.Context) ([]ModelItem, map[string]bool, map[string]b
 		})
 	}

-	cloudDisabled, _ := cloudStatusDisabled(ctx, client)
-	if cloudDisabled {
-		existing = filterCloudModels(existing)
-	}
+	modelItems, _, existingModels, cloudModels := buildModelList(existing, nil, "")

-	items, _, existingModels, cloudModels := buildModelList(existing, nil, "")
-
-	if cloudDisabled {
-		items = filterCloudItems(items)
-	}
-
-	if len(items) == 0 {
+	if len(modelItems) == 0 {
 		return nil, nil, nil, nil, fmt.Errorf("no models available, run 'ollama pull <model>' first")
 	}

-	return items, existingModels, cloudModels, client, nil
-}
-
-func OpenBrowser(url string) {
-	switch runtime.GOOS {
-	case "darwin":
-		_ = exec.Command("open", url).Start()
-	case "linux":
-		_ = exec.Command("xdg-open", url).Start()
-	case "windows":
-		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", url).Start()
+	items := make([]selectItem, len(modelItems))
+	for i, mi := range modelItems {
+		items[i] = selectItem(mi)
 	}
+
+	return items, existingModels, cloudModels, client, nil
 }

 func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]bool, selected []string) error {
@@ -569,9 +505,6 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]
 	if len(selectedCloudModels) == 0 {
 		return nil
 	}
-	if disabled, known := cloudStatusDisabled(ctx, client); known && disabled {
-		return errors.New(internalcloud.DisabledError("remote inference is unavailable"))
-	}

 	user, err := client.Whoami(ctx)
 	if err == nil && user != nil && user.Name != "" {
@@ -584,16 +517,6 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]
 	}

 	modelList := strings.Join(selectedCloudModels, ", ")
-
-	if DefaultSignIn != nil {
-		_, err := DefaultSignIn(modelList, aErr.SigninURL)
-		if err != nil {
-			return fmt.Errorf("%s requires sign in", modelList)
-		}
-		return nil
-	}
-
-	// Fallback: plain text sign-in flow
 	yes, err := confirmPrompt(fmt.Sprintf("sign in to use %s?", modelList))
 	if err != nil || !yes {
 		return fmt.Errorf("%s requires sign in", modelList)
@@ -601,7 +524,14 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]

 	fmt.Fprintf(os.Stderr, "\nTo sign in, navigate to:\n    %s\n\n", aErr.SigninURL)

-	OpenBrowser(aErr.SigninURL)
+	switch runtime.GOOS {
+	case "darwin":
+		_ = exec.Command("open", aErr.SigninURL).Start()
+	case "linux":
+		_ = exec.Command("xdg-open", aErr.SigninURL).Start()
+	case "windows":
+		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", aErr.SigninURL).Start()
+	}

 	spinnerFrames := []string{"|", "/", "-", "\\"}
 	frame := 0
@@ -634,7 +564,7 @@ func ensureAuth(ctx context.Context, client *api.Client, cloudModels map[string]

 // selectModels lets the user select models for an integration using default selectors.
 func selectModels(ctx context.Context, name, current string) ([]string, error) {
-	return selectModelsWithSelectors(ctx, name, current, DefaultSingleSelector, DefaultMultiSelector)
+	return selectModelsWithSelectors(ctx, name, current, defaultSingleSelector, defaultMultiSelector)
 }

 func runIntegration(name, modelName string, args []string) error {
@@ -677,15 +607,8 @@ func LaunchIntegration(name string) error {
 	}

 	// Try to use saved config
-	if ic, err := loadIntegration(name); err == nil && len(ic.Models) > 0 {
-		client, err := api.ClientFromEnvironment()
-		if err != nil {
-			return err
-		}
-		if err := ShowOrPull(context.Background(), client, ic.Models[0]); err != nil {
-			return err
-		}
-		return runIntegration(name, ic.Models[0], nil)
+	if config, err := loadIntegration(name); err == nil && len(config.Models) > 0 {
+		return runIntegration(name, config.Models[0], nil)
 	}

 	// No saved config - prompt user to run setup
@@ -694,55 +617,26 @@ func LaunchIntegration(name string) error {

 // LaunchIntegrationWithModel launches the named integration with the specified model.
 func LaunchIntegrationWithModel(name, modelName string) error {
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return err
-	}
-	if err := ShowOrPull(context.Background(), client, modelName); err != nil {
-		return err
-	}
 	return runIntegration(name, modelName, nil)
 }

-// SaveAndEditIntegration saves the models for an Editor integration and runs its Edit method
-// to write the integration's config files.
-func SaveAndEditIntegration(name string, models []string) error {
-	r, ok := integrations[strings.ToLower(name)]
-	if !ok {
-		return fmt.Errorf("unknown integration: %s", name)
-	}
-	if err := SaveIntegration(name, models); err != nil {
-		return fmt.Errorf("failed to save: %w", err)
-	}
-	if editor, isEditor := r.(Editor); isEditor {
-		if err := editor.Edit(models); err != nil {
-			return fmt.Errorf("setup failed: %w", err)
+// SaveIntegrationModel saves the model for an integration.
+func SaveIntegrationModel(name, modelName string) error {
+	// Load existing models and prepend the new one
+	var models []string
+	if existing, err := loadIntegration(name); err == nil && len(existing.Models) > 0 {
+		models = existing.Models
+		// Remove the model if it already exists
+		for i, m := range models {
+			if m == modelName {
+				models = append(models[:i], models[i+1:]...)
+				break
+			}
 		}
 	}
-	return nil
-}
-
-// resolveEditorModels filters out cloud-disabled models before editor launch.
-// If no models remain, it invokes picker to collect a valid replacement list.
-func resolveEditorModels(name string, models []string, picker func() ([]string, error)) ([]string, error) {
-	filtered := filterDisabledCloudModels(models)
-	if len(filtered) != len(models) {
-		if err := SaveIntegration(name, filtered); err != nil {
-			return nil, fmt.Errorf("failed to save: %w", err)
-		}
-	}
-	if len(filtered) > 0 {
-		return filtered, nil
-	}
-
-	selected, err := picker()
-	if err != nil {
-		return nil, err
-	}
-	if err := SaveIntegration(name, selected); err != nil {
-		return nil, fmt.Errorf("failed to save: %w", err)
-	}
-	return selected, nil
+	// Prepend the new model
+	models = append([]string{modelName}, models...)
+	return saveIntegration(name, models)
 }

 // ConfigureIntegrationWithSelectors allows the user to select/change the model for an integration using custom selectors.
@@ -754,7 +648,7 @@ func ConfigureIntegrationWithSelectors(ctx context.Context, name string, single

 	models, err := selectModelsWithSelectors(ctx, name, "", single, multi)
 	if errors.Is(err, errCancelled) {
-		return errCancelled
+		return nil
 	}
 	if err != nil {
 		return err
@@ -779,7 +673,7 @@ func ConfigureIntegrationWithSelectors(ctx context.Context, name string, single
 		}
 	}

-	if err := SaveIntegration(name, models); err != nil {
+	if err := saveIntegration(name, models); err != nil {
 		return fmt.Errorf("failed to save: %w", err)
 	}

@@ -794,7 +688,7 @@ func ConfigureIntegrationWithSelectors(ctx context.Context, name string, single

 // ConfigureIntegration allows the user to select/change the model for an integration.
 func ConfigureIntegration(ctx context.Context, name string) error {
-	return ConfigureIntegrationWithSelectors(ctx, name, DefaultSingleSelector, DefaultMultiSelector)
+	return ConfigureIntegrationWithSelectors(ctx, name, defaultSingleSelector, defaultMultiSelector)
 }

 // LaunchCmd returns the cobra command for launching integrations.
@@ -827,7 +721,7 @@ Examples:
 		Args:    cobra.ArbitraryArgs,
 		PreRunE: checkServerHeartbeat,
 		RunE: func(cmd *cobra.Command, args []string) error {
-			// No args and no flags - show the full TUI (same as bare 'ollama')
+			// No args - run the main TUI (same as 'ollama')
 			if len(args) == 0 && modelFlag == "" && !configFlag {
 				runTUI(cmd)
 				return nil
@@ -873,10 +767,6 @@ Examples:
 				return fmt.Errorf("unknown integration: %s", name)
 			}

-			if modelFlag != "" && IsCloudModelDisabled(cmd.Context(), modelFlag) {
-				modelFlag = ""
-			}
-
 			// Handle AliasConfigurer integrations (claude, codex)
 			if ac, ok := r.(AliasConfigurer); ok {
 				client, err := api.ClientFromEnvironment()
@@ -886,7 +776,7 @@ Examples:

 				// Validate --model flag if provided
 				if modelFlag != "" {
-					if err := ShowOrPull(cmd.Context(), client, modelFlag); err != nil {
+					if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
 						if errors.Is(err, errCancelled) {
 							return nil
 						}
@@ -904,7 +794,7 @@ Examples:
 						model = cfg.Models[0]
 						// AliasConfigurer integrations use single model; sanitize if multiple
 						if len(cfg.Models) > 1 {
-							_ = SaveIntegration(name, []string{model})
+							_ = saveIntegration(name, []string{model})
 						}
 					}
 				}
@@ -915,14 +805,10 @@ Examples:
 				}

 				// Validate saved model still exists
-				cloudCleared := false
 				if model != "" && modelFlag == "" {
-					if disabled, _ := cloudStatusDisabled(cmd.Context(), client); disabled && isCloudModelName(model) {
-						model = ""
-						cloudCleared = true
-					} else if _, err := client.Show(cmd.Context(), &api.ShowRequest{Model: model}); err != nil {
+					if _, err := client.Show(cmd.Context(), &api.ShowRequest{Model: model}); err != nil {
 						fmt.Fprintf(os.Stderr, "%sConfigured model %q not found%s\n\n", ansiGray, model, ansiReset)
-						if err := ShowOrPull(cmd.Context(), client, model); err != nil {
+						if err := showOrPull(cmd.Context(), client, model); err != nil {
 							model = ""
 						}
 					}
@@ -930,7 +816,7 @@ Examples:

 				// If no valid model or --config flag, show picker
 				if model == "" || configFlag {
-					aliases, _, err := ac.ConfigureAliases(cmd.Context(), model, existingAliases, configFlag || cloudCleared)
+					aliases, _, err := ac.ConfigureAliases(cmd.Context(), model, existingAliases, configFlag)
 					if errors.Is(err, errCancelled) {
 						return nil
 					}
@@ -952,7 +838,7 @@ Examples:
 				if err := syncAliases(cmd.Context(), client, ac, name, model, existingAliases); err != nil {
 					fmt.Fprintf(os.Stderr, "%sWarning: Could not sync aliases: %v%s\n", ansiGray, err, ansiReset)
 				}
-				if err := SaveIntegration(name, []string{model}); err != nil {
+				if err := saveIntegration(name, []string{model}); err != nil {
 					return fmt.Errorf("failed to save: %w", err)
 				}

@@ -972,7 +858,7 @@ Examples:
 				if err != nil {
 					return err
 				}
-				if err := ShowOrPull(cmd.Context(), client, modelFlag); err != nil {
+				if err := showOrPull(cmd.Context(), client, modelFlag); err != nil {
 					if errors.Is(err, errCancelled) {
 						return nil
 					}
@@ -990,35 +876,8 @@ Examples:
 						}
 					}
 				}
-				models = filterDisabledCloudModels(models)
-				if len(models) == 0 {
-					var err error
-					models, err = selectModels(cmd.Context(), name, "")
-					if errors.Is(err, errCancelled) {
-						return nil
-					}
-					if err != nil {
-						return err
-					}
-				}
 			} else if saved, err := loadIntegration(name); err == nil && len(saved.Models) > 0 && !configFlag {
-				savedModels := filterDisabledCloudModels(saved.Models)
-				if len(savedModels) != len(saved.Models) {
-					_ = SaveIntegration(name, savedModels)
-				}
-				if len(savedModels) == 0 {
-					// All saved models were cloud — fall through to picker
-					models, err = selectModels(cmd.Context(), name, "")
-					if errors.Is(err, errCancelled) {
-						return nil
-					}
-					if err != nil {
-						return err
-					}
-				} else {
-					models = savedModels
-					return runIntegration(name, models[0], passArgs)
-				}
+				return runIntegration(name, saved.Models[0], passArgs)
 			} else {
 				var err error
 				models, err = selectModels(cmd.Context(), name, "")
@@ -1045,7 +904,7 @@ Examples:
 				}
 			}

-			if err := SaveIntegration(name, models); err != nil {
+			if err := saveIntegration(name, models); err != nil {
 				return fmt.Errorf("failed to save: %w", err)
 			}

@@ -1094,10 +953,8 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	recommended := make(map[string]bool)
 	var hasLocalModel, hasCloudModel bool

-	recDesc := make(map[string]string)
 	for _, rec := range recommendedModels {
 		recommended[rec.Name] = true
-		recDesc[rec.Name] = rec.Description
 	}

 	for _, m := range existing {
@@ -1110,7 +967,10 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 		}
 		displayName := strings.TrimSuffix(m.Name, ":latest")
 		existingModels[displayName] = true
-		item := ModelItem{Name: displayName, Recommended: recommended[displayName], Description: recDesc[displayName]}
+		item := ModelItem{Name: displayName}
+		if recommended[displayName] {
+			item.Description = "recommended"
+		}
 		items = append(items, item)
 	}

@@ -1119,7 +979,7 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 			continue
 		}
 		items = append(items, rec)
-		if isCloudModelName(rec.Name) {
+		if strings.HasSuffix(rec.Name, ":cloud") {
 			cloudModels[rec.Name] = true
 		}
 	}
@@ -1147,76 +1007,31 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	for i := range items {
 		if !existingModels[items[i].Name] {
 			notInstalled[items[i].Name] = true
-			var parts []string
 			if items[i].Description != "" {
-				parts = append(parts, items[i].Description)
+				items[i].Description += ", install?"
+			} else {
+				items[i].Description = "install?"
 			}
-			if vram := recommendedVRAM[items[i].Name]; vram != "" {
-				parts = append(parts, vram)
-			}
-			parts = append(parts, "(not downloaded)")
-			items[i].Description = strings.Join(parts, ", ")
 		}
 	}

-	// Build a recommended rank map to preserve ordering within tiers.
-	recRank := make(map[string]int)
-	for i, rec := range recommendedModels {
-		recRank[rec.Name] = i + 1 // 1-indexed; 0 means not recommended
-	}
-
-	onlyLocal := hasLocalModel && !hasCloudModel
-
 	if hasLocalModel || hasCloudModel {
 		slices.SortStableFunc(items, func(a, b ModelItem) int {
 			ac, bc := checked[a.Name], checked[b.Name]
 			aNew, bNew := notInstalled[a.Name], notInstalled[b.Name]
-			aRec, bRec := recRank[a.Name] > 0, recRank[b.Name] > 0
-			aCloud, bCloud := cloudModels[a.Name], cloudModels[b.Name]

-			// Checked/pre-selected always first
 			if ac != bc {
 				if ac {
 					return -1
 				}
 				return 1
 			}
-
-			// Recommended above non-recommended
-			if aRec != bRec {
-				if aRec {
-					return -1
-				}
-				return 1
-			}
-
-			// Both recommended
-			if aRec && bRec {
-				if aCloud != bCloud {
-					if onlyLocal {
-						// Local before cloud when only local installed
-						if aCloud {
-							return 1
-						}
-						return -1
-					}
-					// Cloud before local in mixed case
-					if aCloud {
-						return -1
-					}
-					return 1
-				}
-				return recRank[a.Name] - recRank[b.Name]
-			}
-
-			// Both non-recommended: installed before not-installed
-			if aNew != bNew {
+			if !ac && !bc && aNew != bNew {
 				if aNew {
 					return 1
 				}
 				return -1
 			}
-
 			return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
 		})
 	}
@@ -1224,55 +1039,7 @@ func buildModelList(existing []modelInfo, preChecked []string, current string) (
 	return items, preChecked, existingModels, cloudModels
 }

-// IsCloudModelDisabled reports whether the given model name looks like a cloud
-// model and cloud features are currently disabled on the server.
-func IsCloudModelDisabled(ctx context.Context, name string) bool {
-	if !isCloudModelName(name) {
-		return false
-	}
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return false
-	}
-	disabled, _ := cloudStatusDisabled(ctx, client)
-	return disabled
-}
-
-func isCloudModelName(name string) bool {
-	return strings.HasSuffix(name, ":cloud") || strings.HasSuffix(name, "-cloud")
-}
-
-func filterCloudModels(existing []modelInfo) []modelInfo {
-	filtered := existing[:0]
-	for _, m := range existing {
-		if !m.Remote {
-			filtered = append(filtered, m)
-		}
-	}
-	return filtered
-}
-
-// filterDisabledCloudModels removes cloud models from a list when cloud is disabled.
-func filterDisabledCloudModels(models []string) []string {
-	var filtered []string
-	for _, m := range models {
-		if !IsCloudModelDisabled(context.Background(), m) {
-			filtered = append(filtered, m)
-		}
-	}
-	return filtered
-}
-
-func filterCloudItems(items []ModelItem) []ModelItem {
-	filtered := items[:0]
-	for _, item := range items {
-		if !isCloudModelName(item.Name) {
-			filtered = append(filtered, item)
-		}
-	}
-	return filtered
-}
-
+// isCloudModel checks if a model is a cloud model using the Show API.
 func isCloudModel(ctx context.Context, client *api.Client, name string) bool {
 	if client == nil {
 		return false
@@ -1302,11 +1069,6 @@ func GetModelItems(ctx context.Context) ([]ModelItem, map[string]bool) {
 		existing = append(existing, modelInfo{Name: m.Name, Remote: m.RemoteModel != ""})
 	}

-	cloudDisabled, _ := cloudStatusDisabled(ctx, client)
-	if cloudDisabled {
-		existing = filterCloudModels(existing)
-	}
-
 	lastModel := LastModel()
 	var preChecked []string
 	if lastModel != "" {
@@ -1315,25 +1077,30 @@ func GetModelItems(ctx context.Context) ([]ModelItem, map[string]bool) {

 	items, _, existingModels, _ := buildModelList(existing, preChecked, lastModel)

-	if cloudDisabled {
-		items = filterCloudItems(items)
-	}
+	// Sort with last model first, then existing models, then recommendations
+	slices.SortStableFunc(items, func(a, b ModelItem) int {
+		aIsLast := a.Name == lastModel
+		bIsLast := b.Name == lastModel
+		if aIsLast != bIsLast {
+			if aIsLast {
+				return -1
+			}
+			return 1
+		}
+		aExists := existingModels[a.Name]
+		bExists := existingModels[b.Name]
+		if aExists != bExists {
+			if aExists {
+				return -1
+			}
+			return 1
+		}
+		return strings.Compare(strings.ToLower(a.Name), strings.ToLower(b.Name))
+	})

 	return items, existingModels
 }

-func cloudStatusDisabled(ctx context.Context, client *api.Client) (disabled bool, known bool) {
-	status, err := client.CloudStatusExperimental(ctx)
-	if err != nil {
-		var statusErr api.StatusError
-		if errors.As(err, &statusErr) && statusErr.StatusCode == http.StatusNotFound {
-			return false, false
-		}
-		return false, false
-	}
-	return status.Cloud.Disabled, true
-}
-
 func pullModel(ctx context.Context, client *api.Client, model string) error {
 	p := progress.NewProgress(os.Stderr)
 	defer p.Stop()
--- a/cmd/config/integrations_test.go
+++ b/cmd/config/integrations_test.go
@@ -16,28 +16,6 @@ import (
 	"github.com/spf13/cobra"
 )

-type stubEditorRunner struct {
-	edited   [][]string
-	ranModel string
-}
-
-func (s *stubEditorRunner) Run(model string, args []string) error {
-	s.ranModel = model
-	return nil
-}
-
-func (s *stubEditorRunner) String() string { return "StubEditor" }
-
-func (s *stubEditorRunner) Paths() []string { return nil }
-
-func (s *stubEditorRunner) Edit(models []string) error {
-	cloned := append([]string(nil), models...)
-	s.edited = append(s.edited, cloned)
-	return nil
-}
-
-func (s *stubEditorRunner) Models() []string { return nil }
-
 func TestIntegrationLookup(t *testing.T) {
 	tests := []struct {
 		name      string
@@ -116,7 +94,9 @@ func TestLaunchCmd(t *testing.T) {
 	mockCheck := func(cmd *cobra.Command, args []string) error {
 		return nil
 	}
+	// Mock TUI function (not called in these tests)
 	mockTUI := func(cmd *cobra.Command) {}
+
 	cmd := LaunchCmd(mockCheck, mockTUI)

 	t.Run("command structure", func(t *testing.T) {
@@ -171,10 +151,6 @@ func TestLaunchCmd_TUICallback(t *testing.T) {
 	})

 	t.Run("integration arg bypasses TUI", func(t *testing.T) {
-		srv := httptest.NewServer(http.NotFoundHandler())
-		defer srv.Close()
-		t.Setenv("OLLAMA_HOST", srv.URL)
-
 		tuiCalled := false
 		mockTUI := func(cmd *cobra.Command) {
 			tuiCalled = true
@@ -400,7 +376,7 @@ func TestParseArgs(t *testing.T) {
 func TestIsCloudModel(t *testing.T) {
 	// isCloudModel now only uses Show API, so nil client always returns false
 	t.Run("nil client returns false", func(t *testing.T) {
-		models := []string{"glm-5:cloud", "kimi-k2.5:cloud", "local-model"}
+		models := []string{"glm-4.7:cloud", "kimi-k2.5:cloud", "local-model"}
 		for _, model := range models {
 			if isCloudModel(context.Background(), nil, model) {
 				t.Errorf("isCloudModel(%q) with nil client should return false", model)
@@ -420,14 +396,14 @@ func names(items []ModelItem) []string {
 func TestBuildModelList_NoExistingModels(t *testing.T) {
 	items, _, _, _ := buildModelList(nil, nil, "")

-	want := []string{"minimax-m2.5:cloud", "glm-5:cloud", "kimi-k2.5:cloud", "glm-4.7-flash", "qwen3:8b"}
+	want := []string{"glm-4.7-flash", "qwen3:8b", "glm-4.7:cloud", "kimi-k2.5:cloud"}
 	if diff := cmp.Diff(want, names(items)); diff != "" {
 		t.Errorf("with no existing models, items should be recommended in order (-want +got):\n%s", diff)
 	}

 	for _, item := range items {
-		if !strings.HasSuffix(item.Description, "(not downloaded)") {
-			t.Errorf("item %q should have description ending with '(not downloaded)', got %q", item.Name, item.Description)
+		if !strings.HasSuffix(item.Description, "install?") {
+			t.Errorf("item %q should have description ending with 'install?', got %q", item.Name, item.Description)
 		}
 	}
 }
@@ -441,33 +417,31 @@ func TestBuildModelList_OnlyLocalModels_CloudRecsAtBottom(t *testing.T) {
 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)

-	// Recommended pinned at top (local recs first, then cloud recs when only-local), then installed non-recs
-	want := []string{"glm-4.7-flash", "qwen3:8b", "minimax-m2.5:cloud", "glm-5:cloud", "kimi-k2.5:cloud", "llama3.2", "qwen2.5"}
+	want := []string{"llama3.2", "qwen2.5", "glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, local recs before cloud recs (-want +got):\n%s", diff)
+		t.Errorf("cloud recs should be at bottom (-want +got):\n%s", diff)
 	}
 }

 func TestBuildModelList_BothCloudAndLocal_RegularSort(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
+		{Name: "glm-4.7:cloud", Remote: true},
 	}

 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)

-	// All recs pinned at top (cloud before local in mixed case), then non-recs
-	want := []string{"minimax-m2.5:cloud", "glm-5:cloud", "kimi-k2.5:cloud", "glm-4.7-flash", "qwen3:8b", "llama3.2"}
+	want := []string{"glm-4.7:cloud", "llama3.2", "glm-4.7-flash", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, cloud recs first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("mixed models should be alphabetical (-want +got):\n%s", diff)
 	}
 }

 func TestBuildModelList_PreCheckedFirst(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
+		{Name: "glm-4.7:cloud", Remote: true},
 	}

 	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
@@ -481,20 +455,20 @@ func TestBuildModelList_PreCheckedFirst(t *testing.T) {
 func TestBuildModelList_ExistingRecommendedMarked(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "glm-4.7-flash", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
+		{Name: "glm-4.7:cloud", Remote: true},
 	}

 	items, _, _, _ := buildModelList(existing, nil, "")

 	for _, item := range items {
 		switch item.Name {
-		case "glm-4.7-flash", "glm-5:cloud":
-			if strings.HasSuffix(item.Description, "(not downloaded)") {
-				t.Errorf("installed recommended %q should not have '(not downloaded)' suffix, got %q", item.Name, item.Description)
+		case "glm-4.7-flash", "glm-4.7:cloud":
+			if strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("installed recommended %q should not have 'install?' suffix, got %q", item.Name, item.Description)
 			}
-		case "minimax-m2.5:cloud", "kimi-k2.5:cloud", "qwen3:8b":
-			if !strings.HasSuffix(item.Description, "(not downloaded)") {
-				t.Errorf("non-installed recommended %q should have '(not downloaded)' suffix, got %q", item.Name, item.Description)
+		case "kimi-k2.5:cloud", "qwen3:8b":
+			if !strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("non-installed recommended %q should have 'install?' suffix, got %q", item.Name, item.Description)
 			}
 		}
 	}
@@ -503,18 +477,17 @@ func TestBuildModelList_ExistingRecommendedMarked(t *testing.T) {
 func TestBuildModelList_ExistingCloudModelsNotPushedToBottom(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "glm-4.7-flash", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
+		{Name: "glm-4.7:cloud", Remote: true},
 	}

 	items, _, _, _ := buildModelList(existing, nil, "")
 	got := names(items)

-	// glm-4.7-flash and glm-5:cloud are installed so they sort normally;
+	// glm-4.7-flash and glm-4.7:cloud are installed so they sort normally;
 	// kimi-k2.5:cloud and qwen3:8b are not installed so they go to the bottom
-	// All recs: cloud first in mixed case, then local, in rec order within each
-	want := []string{"minimax-m2.5:cloud", "glm-5:cloud", "kimi-k2.5:cloud", "glm-4.7-flash", "qwen3:8b"}
+	want := []string{"glm-4.7-flash", "glm-4.7:cloud", "kimi-k2.5:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("all recs, cloud first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("existing cloud models should sort normally (-want +got):\n%s", diff)
 	}
 }

@@ -529,16 +502,15 @@ func TestBuildModelList_HasRecommendedCloudModel_OnlyNonInstalledAtBottom(t *tes

 	// kimi-k2.5:cloud is installed so it sorts normally;
 	// the rest of the recommendations are not installed so they go to the bottom
-	// All recs pinned at top (cloud first in mixed case), then non-recs
-	want := []string{"minimax-m2.5:cloud", "glm-5:cloud", "kimi-k2.5:cloud", "glm-4.7-flash", "qwen3:8b", "llama3.2"}
+	want := []string{"kimi-k2.5:cloud", "llama3.2", "glm-4.7-flash", "glm-4.7:cloud", "qwen3:8b"}
 	if diff := cmp.Diff(want, got); diff != "" {
-		t.Errorf("recs pinned at top, cloud first in mixed case (-want +got):\n%s", diff)
+		t.Errorf("only non-installed models should be at bottom (-want +got):\n%s", diff)
 	}

 	for _, item := range items {
 		if !slices.Contains([]string{"kimi-k2.5:cloud", "llama3.2"}, item.Name) {
-			if !strings.HasSuffix(item.Description, "(not downloaded)") {
-				t.Errorf("non-installed %q should have '(not downloaded)' suffix, got %q", item.Name, item.Description)
+			if !strings.HasSuffix(item.Description, "install?") {
+				t.Errorf("non-installed %q should have 'install?' suffix, got %q", item.Name, item.Description)
 			}
 		}
 	}
@@ -580,7 +552,7 @@ func TestBuildModelList_LatestTagStripped(t *testing.T) {
 func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
 	existing := []modelInfo{
 		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
+		{Name: "glm-4.7:cloud", Remote: true},
 	}

 	_, _, existingModels, cloudModels := buildModelList(existing, nil, "")
@@ -588,15 +560,15 @@ func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
 	if !existingModels["llama3.2"] {
 		t.Error("llama3.2 should be in existingModels")
 	}
-	if !existingModels["glm-5:cloud"] {
-		t.Error("glm-5:cloud should be in existingModels")
+	if !existingModels["glm-4.7:cloud"] {
+		t.Error("glm-4.7:cloud should be in existingModels")
 	}
 	if existingModels["glm-4.7-flash"] {
 		t.Error("glm-4.7-flash should not be in existingModels (it's a recommendation)")
 	}

-	if !cloudModels["glm-5:cloud"] {
-		t.Error("glm-5:cloud should be in cloudModels")
+	if !cloudModels["glm-4.7:cloud"] {
+		t.Error("glm-4.7:cloud should be in cloudModels")
 	}
 	if !cloudModels["kimi-k2.5:cloud"] {
 		t.Error("kimi-k2.5:cloud should be in cloudModels (recommended cloud)")
@@ -606,107 +578,12 @@ func TestBuildModelList_ReturnsExistingAndCloudMaps(t *testing.T) {
 	}
 }

-func TestBuildModelList_RecommendedFieldSet(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "glm-4.7-flash", Remote: false},
-		{Name: "llama3.2:latest", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-
-	for _, item := range items {
-		switch item.Name {
-		case "glm-4.7-flash", "qwen3:8b", "glm-5:cloud", "kimi-k2.5:cloud":
-			if !item.Recommended {
-				t.Errorf("%q should have Recommended=true", item.Name)
-			}
-		case "llama3.2":
-			if item.Recommended {
-				t.Errorf("%q should have Recommended=false", item.Name)
-			}
-		}
-	}
-}
-
-func TestBuildModelList_MixedCase_CloudRecsFirst(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// Cloud recs should sort before local recs in mixed case
-	cloudIdx := slices.Index(got, "glm-5:cloud")
-	localIdx := slices.Index(got, "glm-4.7-flash")
-	if cloudIdx > localIdx {
-		t.Errorf("cloud recs should be before local recs in mixed case, got %v", got)
-	}
-}
-
-func TestBuildModelList_OnlyLocal_LocalRecsFirst(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// Local recs should sort before cloud recs in only-local case
-	localIdx := slices.Index(got, "glm-4.7-flash")
-	cloudIdx := slices.Index(got, "glm-5:cloud")
-	if localIdx > cloudIdx {
-		t.Errorf("local recs should be before cloud recs in only-local case, got %v", got)
-	}
-}
-
-func TestBuildModelList_RecsAboveNonRecs(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "custom-model", Remote: false},
-	}
-
-	items, _, _, _ := buildModelList(existing, nil, "")
-	got := names(items)
-
-	// All recommended models should appear before non-recommended installed models
-	lastRecIdx := -1
-	firstNonRecIdx := len(got)
-	for i, name := range got {
-		isRec := name == "glm-4.7-flash" || name == "qwen3:8b" || name == "minimax-m2.5:cloud" || name == "glm-5:cloud" || name == "kimi-k2.5:cloud"
-		if isRec && i > lastRecIdx {
-			lastRecIdx = i
-		}
-		if !isRec && i < firstNonRecIdx {
-			firstNonRecIdx = i
-		}
-	}
-	if lastRecIdx > firstNonRecIdx {
-		t.Errorf("all recs should be above non-recs, got %v", got)
-	}
-}
-
-func TestBuildModelList_CheckedBeforeRecs(t *testing.T) {
-	existing := []modelInfo{
-		{Name: "llama3.2:latest", Remote: false},
-		{Name: "glm-5:cloud", Remote: true},
-	}
-
-	items, _, _, _ := buildModelList(existing, []string{"llama3.2"}, "")
-	got := names(items)
-
-	if got[0] != "llama3.2" {
-		t.Errorf("checked model should be first even before recs, got %v", got)
-	}
-}
-
 func TestEditorIntegration_SavedConfigSkipsSelection(t *testing.T) {
 	tmpDir := t.TempDir()
 	setTestHome(t, tmpDir)

 	// Save a config for opencode so it looks like a previous launch
-	if err := SaveIntegration("opencode", []string{"llama3.2"}); err != nil {
+	if err := saveIntegration("opencode", []string{"llama3.2"}); err != nil {
 		t.Fatal(err)
 	}

@@ -723,137 +600,6 @@ func TestEditorIntegration_SavedConfigSkipsSelection(t *testing.T) {
 	}
 }

-func TestResolveEditorLaunchModels_PicksWhenAllFiltered(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/status":
-			fmt.Fprintf(w, `{"cloud":{"disabled":true,"source":"config"}}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-	t.Setenv("OLLAMA_HOST", srv.URL)
-
-	pickerCalled := false
-	models, err := resolveEditorModels("opencode", []string{"glm-5:cloud"}, func() ([]string, error) {
-		pickerCalled = true
-		return []string{"llama3.2"}, nil
-	})
-	if err != nil {
-		t.Fatalf("resolveEditorLaunchModels returned error: %v", err)
-	}
-	if !pickerCalled {
-		t.Fatal("expected model picker to be called when all models are filtered")
-	}
-	if diff := cmp.Diff([]string{"llama3.2"}, models); diff != "" {
-		t.Fatalf("resolved models mismatch (-want +got):\n%s", diff)
-	}
-
-	saved, err := loadIntegration("opencode")
-	if err != nil {
-		t.Fatalf("failed to reload integration config: %v", err)
-	}
-	if diff := cmp.Diff([]string{"llama3.2"}, saved.Models); diff != "" {
-		t.Fatalf("saved models mismatch (-want +got):\n%s", diff)
-	}
-}
-
-func TestResolveEditorLaunchModels_FiltersAndSkipsPickerWhenLocalRemains(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/status":
-			fmt.Fprintf(w, `{"cloud":{"disabled":true,"source":"config"}}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-	t.Setenv("OLLAMA_HOST", srv.URL)
-
-	pickerCalled := false
-	models, err := resolveEditorModels("droid", []string{"llama3.2", "glm-5:cloud"}, func() ([]string, error) {
-		pickerCalled = true
-		return []string{"qwen3:8b"}, nil
-	})
-	if err != nil {
-		t.Fatalf("resolveEditorLaunchModels returned error: %v", err)
-	}
-	if pickerCalled {
-		t.Fatal("picker should not be called when a local model remains")
-	}
-	if diff := cmp.Diff([]string{"llama3.2"}, models); diff != "" {
-		t.Fatalf("resolved models mismatch (-want +got):\n%s", diff)
-	}
-
-	saved, err := loadIntegration("droid")
-	if err != nil {
-		t.Fatalf("failed to reload integration config: %v", err)
-	}
-	if diff := cmp.Diff([]string{"llama3.2"}, saved.Models); diff != "" {
-		t.Fatalf("saved models mismatch (-want +got):\n%s", diff)
-	}
-}
-
-func TestLaunchCmd_ModelFlagFiltersDisabledCloudFromSavedConfig(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	if err := SaveIntegration("stubeditor", []string{"glm-5:cloud"}); err != nil {
-		t.Fatalf("failed to seed saved config: %v", err)
-	}
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/status":
-			fmt.Fprintf(w, `{"cloud":{"disabled":true,"source":"config"}}`)
-		case "/api/show":
-			fmt.Fprintf(w, `{"model":"llama3.2"}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-	t.Setenv("OLLAMA_HOST", srv.URL)
-
-	stub := &stubEditorRunner{}
-	old, existed := integrations["stubeditor"]
-	integrations["stubeditor"] = stub
-	defer func() {
-		if existed {
-			integrations["stubeditor"] = old
-		} else {
-			delete(integrations, "stubeditor")
-		}
-	}()
-
-	cmd := LaunchCmd(func(cmd *cobra.Command, args []string) error { return nil }, func(cmd *cobra.Command) {})
-	cmd.SetArgs([]string{"stubeditor", "--model", "llama3.2"})
-	if err := cmd.Execute(); err != nil {
-		t.Fatalf("launch command failed: %v", err)
-	}
-
-	saved, err := loadIntegration("stubeditor")
-	if err != nil {
-		t.Fatalf("failed to reload integration config: %v", err)
-	}
-	if diff := cmp.Diff([]string{"llama3.2"}, saved.Models); diff != "" {
-		t.Fatalf("saved models mismatch (-want +got):\n%s", diff)
-	}
-	if diff := cmp.Diff([][]string{{"llama3.2"}}, stub.edited); diff != "" {
-		t.Fatalf("editor models mismatch (-want +got):\n%s", diff)
-	}
-	if stub.ranModel != "llama3.2" {
-		t.Fatalf("expected launch to run with llama3.2, got %q", stub.ranModel)
-	}
-}
-
 func TestAliasConfigurerInterface(t *testing.T) {
 	t.Run("claude implements AliasConfigurer", func(t *testing.T) {
 		claude := &Claude{}
@@ -884,7 +630,7 @@ func TestShowOrPull_ModelExists(t *testing.T) {
 	u, _ := url.Parse(srv.URL)
 	client := api.NewClient(u, srv.Client())

-	err := ShowOrPull(context.Background(), client, "test-model")
+	err := showOrPull(context.Background(), client, "test-model")
 	if err != nil {
 		t.Errorf("showOrPull should return nil when model exists, got: %v", err)
 	}
@@ -901,7 +647,7 @@ func TestShowOrPull_ModelNotFound_NoTerminal(t *testing.T) {
 	client := api.NewClient(u, srv.Client())

 	// confirmPrompt will fail in test (no terminal), so showOrPull should return an error
-	err := ShowOrPull(context.Background(), client, "missing-model")
+	err := showOrPull(context.Background(), client, "missing-model")
 	if err == nil {
 		t.Error("showOrPull should return error when model not found and no terminal available")
 	}
@@ -926,141 +672,12 @@ func TestShowOrPull_ShowCalledWithCorrectModel(t *testing.T) {
 	u, _ := url.Parse(srv.URL)
 	client := api.NewClient(u, srv.Client())

-	_ = ShowOrPull(context.Background(), client, "qwen3:8b")
+	_ = showOrPull(context.Background(), client, "qwen3:8b")
 	if receivedModel != "qwen3:8b" {
 		t.Errorf("expected Show to be called with %q, got %q", "qwen3:8b", receivedModel)
 	}
 }

-func TestShowOrPull_ModelNotFound_ConfirmYes_Pulls(t *testing.T) {
-	// Set up hook so confirmPrompt doesn't need a terminal
-	oldHook := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		if !strings.Contains(prompt, "missing-model") {
-			t.Errorf("expected prompt to contain model name, got %q", prompt)
-		}
-		return true, nil
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	var pullCalled bool
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/show":
-			w.WriteHeader(http.StatusNotFound)
-			fmt.Fprintf(w, `{"error":"model not found"}`)
-		case "/api/pull":
-			pullCalled = true
-			w.WriteHeader(http.StatusOK)
-			fmt.Fprintf(w, `{"status":"success"}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	u, _ := url.Parse(srv.URL)
-	client := api.NewClient(u, srv.Client())
-
-	err := ShowOrPull(context.Background(), client, "missing-model")
-	if err != nil {
-		t.Errorf("ShowOrPull should succeed after pull, got: %v", err)
-	}
-	if !pullCalled {
-		t.Error("expected pull to be called when user confirms download")
-	}
-}
-
-func TestShowOrPull_ModelNotFound_ConfirmNo_Cancelled(t *testing.T) {
-	oldHook := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		return false, ErrCancelled
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/show":
-			w.WriteHeader(http.StatusNotFound)
-			fmt.Fprintf(w, `{"error":"model not found"}`)
-		case "/api/pull":
-			t.Error("pull should not be called when user declines")
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	u, _ := url.Parse(srv.URL)
-	client := api.NewClient(u, srv.Client())
-
-	err := ShowOrPull(context.Background(), client, "missing-model")
-	if err == nil {
-		t.Error("ShowOrPull should return error when user declines")
-	}
-}
-
-func TestShowOrPull_CloudModel_SkipsConfirmation(t *testing.T) {
-	// Confirm prompt should NOT be called for cloud models
-	oldHook := DefaultConfirmPrompt
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		t.Error("confirm prompt should not be called for cloud models")
-		return false, nil
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	var pullCalled bool
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		switch r.URL.Path {
-		case "/api/show":
-			w.WriteHeader(http.StatusNotFound)
-			fmt.Fprintf(w, `{"error":"model not found"}`)
-		case "/api/pull":
-			pullCalled = true
-			w.WriteHeader(http.StatusOK)
-			fmt.Fprintf(w, `{"status":"success"}`)
-		default:
-			w.WriteHeader(http.StatusNotFound)
-		}
-	}))
-	defer srv.Close()
-
-	u, _ := url.Parse(srv.URL)
-	client := api.NewClient(u, srv.Client())
-
-	err := ShowOrPull(context.Background(), client, "glm-5:cloud")
-	if err != nil {
-		t.Errorf("ShowOrPull should succeed for cloud model, got: %v", err)
-	}
-	if !pullCalled {
-		t.Error("expected pull to be called for cloud model without confirmation")
-	}
-}
-
-func TestConfirmPrompt_DelegatesToHook(t *testing.T) {
-	oldHook := DefaultConfirmPrompt
-	var hookCalled bool
-	DefaultConfirmPrompt = func(prompt string) (bool, error) {
-		hookCalled = true
-		if prompt != "test prompt?" {
-			t.Errorf("expected prompt %q, got %q", "test prompt?", prompt)
-		}
-		return true, nil
-	}
-	defer func() { DefaultConfirmPrompt = oldHook }()
-
-	ok, err := confirmPrompt("test prompt?")
-	if err != nil {
-		t.Errorf("unexpected error: %v", err)
-	}
-	if !ok {
-		t.Error("expected true from hook")
-	}
-	if !hookCalled {
-		t.Error("expected DefaultConfirmPrompt hook to be called")
-	}
-}
-
 func TestEnsureAuth_NoCloudModels(t *testing.T) {
 	// ensureAuth should be a no-op when no cloud models are selected
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -1131,283 +748,3 @@ func TestEnsureAuth_SkipsWhenNoCloudSelected(t *testing.T) {
 		t.Error("whoami should not be called when no cloud models are selected")
 	}
 }
-
-func TestHyperlink(t *testing.T) {
-	tests := []struct {
-		name     string
-		url      string
-		text     string
-		wantURL  string
-		wantText string
-	}{
-		{
-			name:     "basic link",
-			url:      "https://example.com",
-			text:     "click here",
-			wantURL:  "https://example.com",
-			wantText: "click here",
-		},
-		{
-			name:     "url with path",
-			url:      "https://example.com/docs/install",
-			text:     "install docs",
-			wantURL:  "https://example.com/docs/install",
-			wantText: "install docs",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := hyperlink(tt.url, tt.text)
-
-			// Should contain OSC 8 escape sequences
-			if !strings.Contains(got, "\033]8;;") {
-				t.Error("should contain OSC 8 open sequence")
-			}
-			if !strings.Contains(got, tt.wantURL) {
-				t.Errorf("should contain URL %q", tt.wantURL)
-			}
-			if !strings.Contains(got, tt.wantText) {
-				t.Errorf("should contain text %q", tt.wantText)
-			}
-
-			// Should have closing OSC 8 sequence
-			wantSuffix := "\033]8;;\033\\"
-			if !strings.HasSuffix(got, wantSuffix) {
-				t.Error("should end with OSC 8 close sequence")
-			}
-		})
-	}
-}
-
-func TestIntegrationInstallHint(t *testing.T) {
-	tests := []struct {
-		name      string
-		input     string
-		wantEmpty bool
-		wantURL   string
-	}{
-		{
-			name:    "claude has hint",
-			input:   "claude",
-			wantURL: "https://code.claude.com/docs/en/quickstart",
-		},
-		{
-			name:    "codex has hint",
-			input:   "codex",
-			wantURL: "https://developers.openai.com/codex/cli/",
-		},
-		{
-			name:    "openclaw has hint",
-			input:   "openclaw",
-			wantURL: "https://docs.openclaw.ai",
-		},
-		{
-			name:      "unknown has no hint",
-			input:     "unknown",
-			wantEmpty: true,
-		},
-		{
-			name:      "empty name has no hint",
-			input:     "",
-			wantEmpty: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			got := IntegrationInstallHint(tt.input)
-			if tt.wantEmpty {
-				if got != "" {
-					t.Errorf("expected empty hint, got %q", got)
-				}
-				return
-			}
-			if !strings.Contains(got, "Install from") {
-				t.Errorf("hint should start with 'Install from', got %q", got)
-			}
-			if !strings.Contains(got, tt.wantURL) {
-				t.Errorf("hint should contain URL %q, got %q", tt.wantURL, got)
-			}
-			// Should be a clickable hyperlink
-			if !strings.Contains(got, "\033]8;;") {
-				t.Error("hint URL should be wrapped in OSC 8 hyperlink")
-			}
-		})
-	}
-}
-
-func TestListIntegrationInfos(t *testing.T) {
-	infos := ListIntegrationInfos()
-
-	t.Run("excludes aliases", func(t *testing.T) {
-		for _, info := range infos {
-			if integrationAliases[info.Name] {
-				t.Errorf("alias %q should not appear in ListIntegrationInfos", info.Name)
-			}
-		}
-	})
-
-	t.Run("sorted by name", func(t *testing.T) {
-		for i := 1; i < len(infos); i++ {
-			if infos[i-1].Name >= infos[i].Name {
-				t.Errorf("not sorted: %q >= %q", infos[i-1].Name, infos[i].Name)
-			}
-		}
-	})
-
-	t.Run("all fields populated", func(t *testing.T) {
-		for _, info := range infos {
-			if info.Name == "" {
-				t.Error("Name should not be empty")
-			}
-			if info.DisplayName == "" {
-				t.Errorf("DisplayName for %q should not be empty", info.Name)
-			}
-		}
-	})
-
-	t.Run("includes known integrations", func(t *testing.T) {
-		known := map[string]bool{"claude": false, "codex": false, "opencode": false}
-		for _, info := range infos {
-			if _, ok := known[info.Name]; ok {
-				known[info.Name] = true
-			}
-		}
-		for name, found := range known {
-			if !found {
-				t.Errorf("expected %q in ListIntegrationInfos", name)
-			}
-		}
-	})
-}
-
-func TestBuildModelList_Descriptions(t *testing.T) {
-	t.Run("installed recommended has base description", func(t *testing.T) {
-		existing := []modelInfo{
-			{Name: "qwen3:8b", Remote: false},
-		}
-		items, _, _, _ := buildModelList(existing, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if strings.HasSuffix(item.Description, "install?") {
-					t.Errorf("installed model should not have 'install?' suffix, got %q", item.Description)
-				}
-				if item.Description == "" {
-					t.Error("installed recommended model should have a description")
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-
-	t.Run("not-installed local rec has VRAM in description", func(t *testing.T) {
-		items, _, _, _ := buildModelList(nil, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if !strings.Contains(item.Description, "~11GB") {
-					t.Errorf("not-installed qwen3:8b should show VRAM hint, got %q", item.Description)
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-
-	t.Run("installed local rec omits VRAM", func(t *testing.T) {
-		existing := []modelInfo{
-			{Name: "qwen3:8b", Remote: false},
-		}
-		items, _, _, _ := buildModelList(existing, nil, "")
-
-		for _, item := range items {
-			if item.Name == "qwen3:8b" {
-				if strings.Contains(item.Description, "~11GB") {
-					t.Errorf("installed qwen3:8b should not show VRAM hint, got %q", item.Description)
-				}
-				return
-			}
-		}
-		t.Error("qwen3:8b not found in items")
-	})
-}
-
-func TestLaunchIntegration_UnknownIntegration(t *testing.T) {
-	err := LaunchIntegration("nonexistent-integration")
-	if err == nil {
-		t.Fatal("expected error for unknown integration")
-	}
-	if !strings.Contains(err.Error(), "unknown integration") {
-		t.Errorf("error should mention 'unknown integration', got: %v", err)
-	}
-}
-
-func TestLaunchIntegration_NotConfigured(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	// Claude is a known integration but not configured in temp dir
-	err := LaunchIntegration("claude")
-	if err == nil {
-		t.Fatal("expected error when integration is not configured")
-	}
-	if !strings.Contains(err.Error(), "not configured") {
-		t.Errorf("error should mention 'not configured', got: %v", err)
-	}
-}
-
-func TestIsEditorIntegration(t *testing.T) {
-	tests := []struct {
-		name string
-		want bool
-	}{
-		{"droid", true},
-		{"opencode", true},
-		{"openclaw", true},
-		{"claude", false},
-		{"codex", false},
-		{"nonexistent", false},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := IsEditorIntegration(tt.name); got != tt.want {
-				t.Errorf("IsEditorIntegration(%q) = %v, want %v", tt.name, got, tt.want)
-			}
-		})
-	}
-}
-
-func TestIntegrationModels(t *testing.T) {
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	t.Run("returns nil when not configured", func(t *testing.T) {
-		if got := IntegrationModels("droid"); got != nil {
-			t.Errorf("expected nil, got %v", got)
-		}
-	})
-
-	t.Run("returns all saved models", func(t *testing.T) {
-		if err := SaveIntegration("droid", []string{"llama3.2", "qwen3:8b"}); err != nil {
-			t.Fatal(err)
-		}
-		got := IntegrationModels("droid")
-		want := []string{"llama3.2", "qwen3:8b"}
-		if diff := cmp.Diff(want, got); diff != "" {
-			t.Errorf("IntegrationModels mismatch (-want +got):\n%s", diff)
-		}
-	})
-}
-
-func TestSaveAndEditIntegration_UnknownIntegration(t *testing.T) {
-	err := SaveAndEditIntegration("nonexistent", []string{"model"})
-	if err == nil {
-		t.Fatal("expected error for unknown integration")
-	}
-	if !strings.Contains(err.Error(), "unknown integration") {
-		t.Errorf("error should mention 'unknown integration', got: %v", err)
-	}
-}
--- a/cmd/config/openclaw.go
+++ b/cmd/config/openclaw.go
@@ -2,9 +2,7 @@ package config

 import (
 	"bytes"
-	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -34,16 +32,6 @@ func (c *Openclaw) Run(model string, args []string) error {
 	} else if config, err := loadIntegration("clawdbot"); err == nil && len(config.Models) > 0 {
 		models = config.Models
 	}
-	var err error
-	models, err = resolveEditorModels("openclaw", models, func() ([]string, error) {
-		return selectModels(context.Background(), "openclaw", "")
-	})
-	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)
 	}
@@ -70,7 +58,7 @@ func (c *Openclaw) Run(model string, args []string) error {
 	cmd.Stdout = io.MultiWriter(os.Stdout, &outputBuf)
 	cmd.Stderr = io.MultiWriter(os.Stderr, &outputBuf)

-	err = cmd.Run()
+	err := cmd.Run()
 	if err != nil && strings.Contains(outputBuf.String(), "Gateway already running") {
 		fmt.Fprintf(os.Stderr, "%sOpenClaw has been configured with Ollama. Gateway is already running.%s\n", ansiGreen, ansiReset)
 		return nil
--- a/cmd/config/opencode.go
+++ b/cmd/config/opencode.go
@@ -3,7 +3,6 @@ package config
 import (
 	"context"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"maps"
 	"os"
@@ -25,6 +24,25 @@ type cloudModelLimit struct {
 	Output  int
 }

+// cloudModelLimits maps cloud model base names to their token limits.
+// TODO(parthsareen): grab context/output limits from model info instead of hardcoding
+var cloudModelLimits = map[string]cloudModelLimit{
+	"cogito-2.1:671b":     {Context: 163_840, Output: 65_536},
+	"deepseek-v3.1:671b":  {Context: 163_840, Output: 163_840},
+	"deepseek-v3.2":       {Context: 163_840, Output: 65_536},
+	"glm-4.6":             {Context: 202_752, Output: 131_072},
+	"glm-4.7":             {Context: 202_752, Output: 131_072},
+	"gpt-oss:120b":        {Context: 131_072, Output: 131_072},
+	"gpt-oss:20b":         {Context: 131_072, Output: 131_072},
+	"kimi-k2:1t":          {Context: 262_144, Output: 262_144},
+	"kimi-k2.5":           {Context: 262_144, Output: 262_144},
+	"kimi-k2-thinking":    {Context: 262_144, Output: 262_144},
+	"nemotron-3-nano:30b": {Context: 1_048_576, Output: 131_072},
+	"qwen3-coder:480b":    {Context: 262_144, Output: 65_536},
+	"qwen3-coder-next":    {Context: 262_144, Output: 32_768},
+	"qwen3-next:80b":      {Context: 262_144, Output: 32_768},
+}
+
 // 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) {
@@ -52,16 +70,6 @@ func (o *OpenCode) Run(model string, args []string) error {
 	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)
 	}
--- a/cmd/config/selector.go
+++ b/cmd/config/selector.go
@@ -3,34 +3,475 @@ package config
 import (
 	"errors"
 	"fmt"
+	"io"
 	"os"
+	"strings"

 	"golang.org/x/term"
 )

 // ANSI escape sequences for terminal formatting.
 const (
-	ansiBold  = "\033[1m"
-	ansiReset = "\033[0m"
-	ansiGray  = "\033[37m"
-	ansiGreen = "\033[32m"
+	ansiHideCursor = "\033[?25l"
+	ansiShowCursor = "\033[?25h"
+	ansiBold       = "\033[1m"
+	ansiReset      = "\033[0m"
+	ansiGray       = "\033[37m"
+	ansiGreen      = "\033[32m"
+	ansiClearDown  = "\033[J"
 )

-// ErrCancelled is returned when the user cancels a selection.
-var ErrCancelled = errors.New("cancelled")
+const maxDisplayedItems = 10

-// errCancelled is kept as an alias for backward compatibility within the package.
-var errCancelled = ErrCancelled
+var errCancelled = errors.New("cancelled")

-// 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)
+type selectItem struct {
+	Name        string
+	Description string
+}

-func confirmPrompt(prompt string) (bool, error) {
-	if DefaultConfirmPrompt != nil {
-		return DefaultConfirmPrompt(prompt)
+type inputEvent int
+
+const (
+	eventNone inputEvent = iota
+	eventEnter
+	eventEscape
+	eventUp
+	eventDown
+	eventTab
+	eventBackspace
+	eventChar
+)
+
+type selectState struct {
+	items        []selectItem
+	filter       string
+	selected     int
+	scrollOffset int
+}
+
+func newSelectState(items []selectItem) *selectState {
+	return &selectState{items: items}
+}
+
+func (s *selectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *selectState) handleInput(event inputEvent, char byte) (done bool, result string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if len(filtered) > 0 && s.selected < len(filtered) {
+			return true, filtered[s.selected].Name, nil
+		}
+	case eventEscape:
+		return true, "", errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.selected = 0
+			s.scrollOffset = 0
+		}
+	case eventUp:
+		if s.selected > 0 {
+			s.selected--
+			if s.selected < s.scrollOffset {
+				s.scrollOffset = s.selected
+			}
+		}
+	case eventDown:
+		if s.selected < len(filtered)-1 {
+			s.selected++
+			if s.selected >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.selected - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.selected = 0
+		s.scrollOffset = 0
 	}

+	return false, "", nil
+}
+
+type multiSelectState struct {
+	items         []selectItem
+	itemIndex     map[string]int
+	filter        string
+	highlighted   int
+	scrollOffset  int
+	checked       map[int]bool
+	checkOrder    []int
+	focusOnButton bool
+}
+
+func newMultiSelectState(items []selectItem, preChecked []string) *multiSelectState {
+	s := &multiSelectState{
+		items:     items,
+		itemIndex: make(map[string]int, len(items)),
+		checked:   make(map[int]bool),
+	}
+
+	for i, item := range items {
+		s.itemIndex[item.Name] = i
+	}
+
+	for _, name := range preChecked {
+		if idx, ok := s.itemIndex[name]; ok {
+			s.checked[idx] = true
+			s.checkOrder = append(s.checkOrder, idx)
+		}
+	}
+
+	return s
+}
+
+func (s *multiSelectState) filtered() []selectItem {
+	return filterItems(s.items, s.filter)
+}
+
+func (s *multiSelectState) toggleItem() {
+	filtered := s.filtered()
+	if len(filtered) == 0 || s.highlighted >= len(filtered) {
+		return
+	}
+
+	item := filtered[s.highlighted]
+	origIdx := s.itemIndex[item.Name]
+
+	if s.checked[origIdx] {
+		delete(s.checked, origIdx)
+		for i, idx := range s.checkOrder {
+			if idx == origIdx {
+				s.checkOrder = append(s.checkOrder[:i], s.checkOrder[i+1:]...)
+				break
+			}
+		}
+	} else {
+		s.checked[origIdx] = true
+		s.checkOrder = append(s.checkOrder, origIdx)
+	}
+}
+
+func (s *multiSelectState) handleInput(event inputEvent, char byte) (done bool, result []string, err error) {
+	filtered := s.filtered()
+
+	switch event {
+	case eventEnter:
+		if s.focusOnButton && len(s.checkOrder) > 0 {
+			var res []string
+			for _, idx := range s.checkOrder {
+				res = append(res, s.items[idx].Name)
+			}
+			return true, res, nil
+		} else if !s.focusOnButton {
+			s.toggleItem()
+		}
+	case eventTab:
+		if len(s.checkOrder) > 0 {
+			s.focusOnButton = !s.focusOnButton
+		}
+	case eventEscape:
+		return true, nil, errCancelled
+	case eventBackspace:
+		if len(s.filter) > 0 {
+			s.filter = s.filter[:len(s.filter)-1]
+			s.highlighted = 0
+			s.scrollOffset = 0
+			s.focusOnButton = false
+		}
+	case eventUp:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted > 0 {
+			s.highlighted--
+			if s.highlighted < s.scrollOffset {
+				s.scrollOffset = s.highlighted
+			}
+		}
+	case eventDown:
+		if s.focusOnButton {
+			s.focusOnButton = false
+		} else if s.highlighted < len(filtered)-1 {
+			s.highlighted++
+			if s.highlighted >= s.scrollOffset+maxDisplayedItems {
+				s.scrollOffset = s.highlighted - maxDisplayedItems + 1
+			}
+		}
+	case eventChar:
+		s.filter += string(char)
+		s.highlighted = 0
+		s.scrollOffset = 0
+		s.focusOnButton = false
+	}
+
+	return false, nil, nil
+}
+
+func (s *multiSelectState) selectedCount() int {
+	return len(s.checkOrder)
+}
+
+// Terminal I/O handling
+
+type terminalState struct {
+	fd       int
+	oldState *term.State
+}
+
+func enterRawMode() (*terminalState, error) {
+	fd := int(os.Stdin.Fd())
+	oldState, err := term.MakeRaw(fd)
+	if err != nil {
+		return nil, err
+	}
+	fmt.Fprint(os.Stderr, ansiHideCursor)
+	return &terminalState{fd: fd, oldState: oldState}, nil
+}
+
+func (t *terminalState) restore() {
+	fmt.Fprint(os.Stderr, ansiShowCursor)
+	term.Restore(t.fd, t.oldState)
+}
+
+func clearLines(n int) {
+	if n > 0 {
+		fmt.Fprintf(os.Stderr, "\033[%dA", n)
+		fmt.Fprint(os.Stderr, ansiClearDown)
+	}
+}
+
+func parseInput(r io.Reader) (inputEvent, byte, error) {
+	buf := make([]byte, 3)
+	n, err := r.Read(buf)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	switch {
+	case n == 1 && buf[0] == 13:
+		return eventEnter, 0, nil
+	case n == 1 && (buf[0] == 3 || buf[0] == 27):
+		return eventEscape, 0, nil
+	case n == 1 && buf[0] == 9:
+		return eventTab, 0, nil
+	case n == 1 && buf[0] == 127:
+		return eventBackspace, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 65:
+		return eventUp, 0, nil
+	case n == 3 && buf[0] == 27 && buf[1] == 91 && buf[2] == 66:
+		return eventDown, 0, nil
+	case n == 1 && buf[0] >= 32 && buf[0] < 127:
+		return eventChar, buf[0], nil
+	}
+
+	return eventNone, 0, nil
+}
+
+// Rendering
+
+func renderSelect(w io.Writer, prompt string, s *selectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			prefix := "    "
+			if idx == s.selected {
+				prefix = "  " + ansiBold + "> "
+			}
+			if item.Description != "" {
+				fmt.Fprintf(w, "%s%s%s %s- %s%s\r\n", prefix, item.Name, ansiReset, ansiGray, item.Description, ansiReset)
+			} else {
+				fmt.Fprintf(w, "%s%s%s\r\n", prefix, item.Name, ansiReset)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	return lineCount
+}
+
+func renderMultiSelect(w io.Writer, prompt string, s *multiSelectState) int {
+	filtered := s.filtered()
+
+	if s.filter == "" {
+		fmt.Fprintf(w, "%s %sType to filter...%s\r\n", prompt, ansiGray, ansiReset)
+	} else {
+		fmt.Fprintf(w, "%s %s\r\n", prompt, s.filter)
+	}
+	lineCount := 1
+
+	if len(filtered) == 0 {
+		fmt.Fprintf(w, "  %s(no matches)%s\r\n", ansiGray, ansiReset)
+		lineCount++
+	} else {
+		displayCount := min(len(filtered), maxDisplayedItems)
+
+		for i := range displayCount {
+			idx := s.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+			origIdx := s.itemIndex[item.Name]
+
+			checkbox := "[ ]"
+			if s.checked[origIdx] {
+				checkbox = "[x]"
+			}
+
+			prefix := "  "
+			suffix := ""
+			if idx == s.highlighted && !s.focusOnButton {
+				prefix = "> "
+			}
+			if len(s.checkOrder) > 0 && s.checkOrder[0] == origIdx {
+				suffix = " " + ansiGray + "(default)" + ansiReset
+			}
+
+			desc := ""
+			if item.Description != "" {
+				desc = " " + ansiGray + "- " + item.Description + ansiReset
+			}
+
+			if idx == s.highlighted && !s.focusOnButton {
+				fmt.Fprintf(w, "  %s%s %s %s%s%s%s\r\n", ansiBold, prefix, checkbox, item.Name, ansiReset, desc, suffix)
+			} else {
+				fmt.Fprintf(w, "  %s %s %s%s%s\r\n", prefix, checkbox, item.Name, desc, suffix)
+			}
+			lineCount++
+		}
+
+		if remaining := len(filtered) - s.scrollOffset - displayCount; remaining > 0 {
+			fmt.Fprintf(w, "  %s... and %d more%s\r\n", ansiGray, remaining, ansiReset)
+			lineCount++
+		}
+	}
+
+	fmt.Fprintf(w, "\r\n")
+	lineCount++
+	count := s.selectedCount()
+	switch {
+	case count == 0:
+		fmt.Fprintf(w, "  %sSelect at least one model.%s\r\n", ansiGray, ansiReset)
+	case s.focusOnButton:
+		fmt.Fprintf(w, "  %s> [ Continue ]%s %s(%d selected)%s\r\n", ansiBold, ansiReset, ansiGray, count, ansiReset)
+	default:
+		fmt.Fprintf(w, "    %s[ Continue ] (%d selected) - press Tab%s\r\n", ansiGray, count, ansiReset)
+	}
+	lineCount++
+
+	return lineCount
+}
+
+// selectPrompt prompts the user to select a single item from a list.
+func selectPrompt(prompt string, items []selectItem) (string, error) {
+	if len(items) == 0 {
+		return "", fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return "", err
+	}
+	defer ts.restore()
+
+	state := newSelectState(items)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return "", err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return "", err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+// multiSelectPrompt prompts the user to select multiple items from a list.
+func multiSelectPrompt(prompt string, items []selectItem, preChecked []string) ([]string, error) {
+	if len(items) == 0 {
+		return nil, fmt.Errorf("no items to select from")
+	}
+
+	ts, err := enterRawMode()
+	if err != nil {
+		return nil, err
+	}
+	defer ts.restore()
+
+	state := newMultiSelectState(items, preChecked)
+	var lastLineCount int
+
+	render := func() {
+		clearLines(lastLineCount)
+		lastLineCount = renderMultiSelect(os.Stderr, prompt, state)
+	}
+
+	render()
+
+	for {
+		event, char, err := parseInput(os.Stdin)
+		if err != nil {
+			return nil, err
+		}
+
+		done, result, err := state.handleInput(event, char)
+		if done {
+			clearLines(lastLineCount)
+			if err != nil {
+				return nil, err
+			}
+			return result, nil
+		}
+
+		render()
+	}
+}
+
+func confirmPrompt(prompt string) (bool, error) {
 	fd := int(os.Stdin.Fd())
 	oldState, err := term.MakeRaw(fd)
 	if err != nil {
@@ -56,3 +497,17 @@ func confirmPrompt(prompt string) (bool, error) {
 		}
 	}
 }
+
+func filterItems(items []selectItem, filter string) []selectItem {
+	if filter == "" {
+		return items
+	}
+	var result []selectItem
+	filterLower := strings.ToLower(filter)
+	for _, item := range items {
+		if strings.Contains(strings.ToLower(item.Name), filterLower) {
+			result = append(result, item)
+		}
+	}
+	return result
+}
--- a/cmd/config/selector_test.go
+++ b/cmd/config/selector_test.go
@@ -1,9 +1,670 @@
 package config

 import (
+	"bytes"
+	"strings"
 	"testing"
 )

+func TestFilterItems(t *testing.T) {
+	items := []selectItem{
+		{Name: "llama3.2:latest"},
+		{Name: "qwen2.5:7b"},
+		{Name: "deepseek-v3:cloud"},
+		{Name: "GPT-OSS:20b"},
+	}
+
+	t.Run("EmptyFilter_ReturnsAllItems", func(t *testing.T) {
+		result := filterItems(items, "")
+		if len(result) != len(items) {
+			t.Errorf("expected %d items, got %d", len(items), len(result))
+		}
+	})
+
+	t.Run("CaseInsensitive_UppercaseFilterMatchesLowercase", func(t *testing.T) {
+		result := filterItems(items, "LLAMA")
+		if len(result) != 1 || result[0].Name != "llama3.2:latest" {
+			t.Errorf("expected llama3.2:latest, got %v", result)
+		}
+	})
+
+	t.Run("CaseInsensitive_LowercaseFilterMatchesUppercase", func(t *testing.T) {
+		result := filterItems(items, "gpt")
+		if len(result) != 1 || result[0].Name != "GPT-OSS:20b" {
+			t.Errorf("expected GPT-OSS:20b, got %v", result)
+		}
+	})
+
+	t.Run("PartialMatch", func(t *testing.T) {
+		result := filterItems(items, "deep")
+		if len(result) != 1 || result[0].Name != "deepseek-v3:cloud" {
+			t.Errorf("expected deepseek-v3:cloud, got %v", result)
+		}
+	})
+
+	t.Run("NoMatch_ReturnsEmpty", func(t *testing.T) {
+		result := filterItems(items, "nonexistent")
+		if len(result) != 0 {
+			t.Errorf("expected 0 items, got %d", len(result))
+		}
+	})
+}
+
+func TestSelectState(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+		{Name: "item3"},
+	}
+
+	t.Run("InitialState", func(t *testing.T) {
+		s := newSelectState(items)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0, got %d", s.selected)
+		}
+		if s.filter != "" {
+			t.Errorf("expected empty filter, got %q", s.filter)
+		}
+		if s.scrollOffset != 0 {
+			t.Errorf("expected scrollOffset=0, got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Enter_SelectsCurrentItem", func(t *testing.T) {
+		s := newSelectState(items)
+		done, result, err := s.handleInput(eventEnter, 0)
+		if !done || result != "item1" || err != nil {
+			t.Errorf("expected (true, item1, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_WithFilter_SelectsFilteredItem", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "item3"
+		done, result, err := s.handleInput(eventEnter, 0)
+		if !done || result != "item3" || err != nil {
+			t.Errorf("expected (true, item3, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_EmptyFilteredList_DoesNothing", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "nonexistent"
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != "" || err != nil {
+			t.Errorf("expected (false, '', nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Enter_EmptyFilteredList_EmptyFilter_DoesNothing", func(t *testing.T) {
+		s := newSelectState([]selectItem{})
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != "" || err != nil {
+			t.Errorf("expected (false, '', nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Escape_ReturnsCancelledError", func(t *testing.T) {
+		s := newSelectState(items)
+		done, result, err := s.handleInput(eventEscape, 0)
+		if !done || result != "" || err != errCancelled {
+			t.Errorf("expected (true, '', errCancelled), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Down_MovesSelection", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventDown, 0)
+		if s.selected != 1 {
+			t.Errorf("expected selected=1, got %d", s.selected)
+		}
+	})
+
+	t.Run("Down_AtBottom_StaysAtBottom", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventDown, 0)
+		if s.selected != 2 {
+			t.Errorf("expected selected=2 (stayed at bottom), got %d", s.selected)
+		}
+	})
+
+	t.Run("Up_MovesSelection", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventUp, 0)
+		if s.selected != 1 {
+			t.Errorf("expected selected=1, got %d", s.selected)
+		}
+	})
+
+	t.Run("Up_AtTop_StaysAtTop", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventUp, 0)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 (stayed at top), got %d", s.selected)
+		}
+	})
+
+	t.Run("Char_AppendsToFilter", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventChar, 'i')
+		s.handleInput(eventChar, 't')
+		s.handleInput(eventChar, 'e')
+		s.handleInput(eventChar, 'm')
+		s.handleInput(eventChar, '2')
+		if s.filter != "item2" {
+			t.Errorf("expected filter='item2', got %q", s.filter)
+		}
+		filtered := s.filtered()
+		if len(filtered) != 1 || filtered[0].Name != "item2" {
+			t.Errorf("expected [item2], got %v", filtered)
+		}
+	})
+
+	t.Run("Char_ResetsSelectionToZero", func(t *testing.T) {
+		s := newSelectState(items)
+		s.selected = 2
+		s.handleInput(eventChar, 'x')
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 after typing, got %d", s.selected)
+		}
+	})
+
+	t.Run("Backspace_RemovesLastFilterChar", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "test"
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "tes" {
+			t.Errorf("expected filter='tes', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_EmptyFilter_DoesNothing", func(t *testing.T) {
+		s := newSelectState(items)
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "" {
+			t.Errorf("expected filter='', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_ResetsSelectionToZero", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "test"
+		s.selected = 2
+		s.handleInput(eventBackspace, 0)
+		if s.selected != 0 {
+			t.Errorf("expected selected=0 after backspace, got %d", s.selected)
+		}
+	})
+
+	t.Run("Scroll_DownPastVisibleItems_ScrollsViewport", func(t *testing.T) {
+		// maxDisplayedItems is 10, so with 15 items we need to scroll
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+
+		// move down 12 times (past the 10-item viewport)
+		for range 12 {
+			s.handleInput(eventDown, 0)
+		}
+
+		if s.selected != 12 {
+			t.Errorf("expected selected=12, got %d", s.selected)
+		}
+		if s.scrollOffset != 3 {
+			t.Errorf("expected scrollOffset=3 (12-10+1), got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Scroll_UpPastScrollOffset_ScrollsViewport", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+		s.selected = 5
+		s.scrollOffset = 5
+
+		s.handleInput(eventUp, 0)
+
+		if s.selected != 4 {
+			t.Errorf("expected selected=4, got %d", s.selected)
+		}
+		if s.scrollOffset != 4 {
+			t.Errorf("expected scrollOffset=4, got %d", s.scrollOffset)
+		}
+	})
+}
+
+func TestMultiSelectState(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+		{Name: "item3"},
+	}
+
+	t.Run("InitialState_NoPrechecked", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+		if s.selectedCount() != 0 {
+			t.Errorf("expected 0 selected, got %d", s.selectedCount())
+		}
+		if s.focusOnButton {
+			t.Error("expected focusOnButton=false initially")
+		}
+	})
+
+	t.Run("InitialState_WithPrechecked", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item3"})
+		if s.selectedCount() != 2 {
+			t.Errorf("expected 2 selected, got %d", s.selectedCount())
+		}
+		if !s.checked[1] || !s.checked[2] {
+			t.Error("expected item2 and item3 to be checked")
+		}
+	})
+
+	t.Run("Prechecked_PreservesSelectionOrder", func(t *testing.T) {
+		// order matters: first checked = default model
+		s := newMultiSelectState(items, []string{"item3", "item1"})
+		if len(s.checkOrder) != 2 {
+			t.Fatalf("expected 2 in checkOrder, got %d", len(s.checkOrder))
+		}
+		if s.checkOrder[0] != 2 || s.checkOrder[1] != 0 {
+			t.Errorf("expected checkOrder=[2,0] (item3 first), got %v", s.checkOrder)
+		}
+	})
+
+	t.Run("Prechecked_IgnoresInvalidNames", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "nonexistent"})
+		if s.selectedCount() != 1 {
+			t.Errorf("expected 1 selected (nonexistent ignored), got %d", s.selectedCount())
+		}
+	})
+
+	t.Run("Toggle_ChecksUncheckedItem", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.toggleItem()
+		if !s.checked[0] {
+			t.Error("expected item1 to be checked after toggle")
+		}
+	})
+
+	t.Run("Toggle_UnchecksCheckedItem", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.toggleItem()
+		if s.checked[0] {
+			t.Error("expected item1 to be unchecked after toggle")
+		}
+	})
+
+	t.Run("Toggle_RemovesFromCheckOrder", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "item2", "item3"})
+		s.highlighted = 1 // toggle item2
+		s.toggleItem()
+
+		if len(s.checkOrder) != 2 {
+			t.Fatalf("expected 2 in checkOrder, got %d", len(s.checkOrder))
+		}
+		// should be [0, 2] (item1, item3) with item2 removed
+		if s.checkOrder[0] != 0 || s.checkOrder[1] != 2 {
+			t.Errorf("expected checkOrder=[0,2], got %v", s.checkOrder)
+		}
+	})
+
+	t.Run("Enter_TogglesWhenNotOnButton", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventEnter, 0)
+		if !s.checked[0] {
+			t.Error("expected item1 to be checked after enter")
+		}
+	})
+
+	t.Run("Enter_OnButton_ReturnsSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item1"})
+		s.focusOnButton = true
+
+		done, result, err := s.handleInput(eventEnter, 0)
+
+		if !done || err != nil {
+			t.Errorf("expected done=true, err=nil, got done=%v, err=%v", done, err)
+		}
+		// result should preserve selection order
+		if len(result) != 2 || result[0] != "item2" || result[1] != "item1" {
+			t.Errorf("expected [item2, item1], got %v", result)
+		}
+	})
+
+	t.Run("Enter_OnButton_EmptySelection_DoesNothing", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.focusOnButton = true
+		done, result, err := s.handleInput(eventEnter, 0)
+		if done || result != nil || err != nil {
+			t.Errorf("expected (false, nil, nil), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("Tab_SwitchesToButton_WhenHasSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.handleInput(eventTab, 0)
+		if !s.focusOnButton {
+			t.Error("expected focus on button after tab")
+		}
+	})
+
+	t.Run("Tab_DoesNothing_WhenNoSelection", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventTab, 0)
+		if s.focusOnButton {
+			t.Error("tab should not focus button when nothing selected")
+		}
+	})
+
+	t.Run("Tab_TogglesButtonFocus", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.handleInput(eventTab, 0)
+		if !s.focusOnButton {
+			t.Error("expected focus on button after first tab")
+		}
+		s.handleInput(eventTab, 0)
+		if s.focusOnButton {
+			t.Error("expected focus back on list after second tab")
+		}
+	})
+
+	t.Run("Escape_ReturnsCancelledError", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		done, result, err := s.handleInput(eventEscape, 0)
+		if !done || result != nil || err != errCancelled {
+			t.Errorf("expected (true, nil, errCancelled), got (%v, %v, %v)", done, result, err)
+		}
+	})
+
+	t.Run("IsDefault_TrueForFirstChecked", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item2", "item1"})
+		if !(len(s.checkOrder) > 0 && s.checkOrder[0] == 1) {
+			t.Error("expected item2 (idx 1) to be default (first checked)")
+		}
+		if len(s.checkOrder) > 0 && s.checkOrder[0] == 0 {
+			t.Error("expected item1 (idx 0) to NOT be default")
+		}
+	})
+
+	t.Run("IsDefault_FalseWhenNothingChecked", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		if len(s.checkOrder) > 0 && s.checkOrder[0] == 0 {
+			t.Error("expected isDefault=false when nothing checked")
+		}
+	})
+
+	t.Run("Down_MovesHighlight", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventDown, 0)
+		if s.highlighted != 1 {
+			t.Errorf("expected highlighted=1, got %d", s.highlighted)
+		}
+	})
+
+	t.Run("Up_MovesHighlight", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.highlighted = 1
+		s.handleInput(eventUp, 0)
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+	})
+
+	t.Run("Arrow_ReturnsFocusFromButton", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.focusOnButton = true
+		s.handleInput(eventDown, 0)
+		if s.focusOnButton {
+			t.Error("expected focus to return to list on arrow key")
+		}
+	})
+
+	t.Run("Char_AppendsToFilter", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.handleInput(eventChar, 'x')
+		if s.filter != "x" {
+			t.Errorf("expected filter='x', got %q", s.filter)
+		}
+	})
+
+	t.Run("Char_ResetsHighlightAndScroll", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newMultiSelectState(manyItems, nil)
+		s.highlighted = 10
+		s.scrollOffset = 5
+
+		s.handleInput(eventChar, 'x')
+
+		if s.highlighted != 0 {
+			t.Errorf("expected highlighted=0, got %d", s.highlighted)
+		}
+		if s.scrollOffset != 0 {
+			t.Errorf("expected scrollOffset=0, got %d", s.scrollOffset)
+		}
+	})
+
+	t.Run("Backspace_RemovesLastFilterChar", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		s.filter = "test"
+		s.handleInput(eventBackspace, 0)
+		if s.filter != "tes" {
+			t.Errorf("expected filter='tes', got %q", s.filter)
+		}
+	})
+
+	t.Run("Backspace_RemovesFocusFromButton", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		s.filter = "x"
+		s.focusOnButton = true
+		s.handleInput(eventBackspace, 0)
+		if s.focusOnButton {
+			t.Error("expected focusOnButton=false after backspace")
+		}
+	})
+}
+
+func TestParseInput(t *testing.T) {
+	t.Run("Enter", func(t *testing.T) {
+		event, char, err := parseInput(bytes.NewReader([]byte{13}))
+		if err != nil || event != eventEnter || char != 0 {
+			t.Errorf("expected (eventEnter, 0, nil), got (%v, %v, %v)", event, char, err)
+		}
+	})
+
+	t.Run("Escape", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27}))
+		if err != nil || event != eventEscape {
+			t.Errorf("expected eventEscape, got %v", event)
+		}
+	})
+
+	t.Run("CtrlC_TreatedAsEscape", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{3}))
+		if err != nil || event != eventEscape {
+			t.Errorf("expected eventEscape for Ctrl+C, got %v", event)
+		}
+	})
+
+	t.Run("Tab", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{9}))
+		if err != nil || event != eventTab {
+			t.Errorf("expected eventTab, got %v", event)
+		}
+	})
+
+	t.Run("Backspace", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{127}))
+		if err != nil || event != eventBackspace {
+			t.Errorf("expected eventBackspace, got %v", event)
+		}
+	})
+
+	t.Run("UpArrow", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27, 91, 65}))
+		if err != nil || event != eventUp {
+			t.Errorf("expected eventUp, got %v", event)
+		}
+	})
+
+	t.Run("DownArrow", func(t *testing.T) {
+		event, _, err := parseInput(bytes.NewReader([]byte{27, 91, 66}))
+		if err != nil || event != eventDown {
+			t.Errorf("expected eventDown, got %v", event)
+		}
+	})
+
+	t.Run("PrintableChars", func(t *testing.T) {
+		tests := []struct {
+			name string
+			char byte
+		}{
+			{"lowercase", 'a'},
+			{"uppercase", 'Z'},
+			{"digit", '5'},
+			{"space", ' '},
+			{"tilde", '~'},
+		}
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				event, char, err := parseInput(bytes.NewReader([]byte{tt.char}))
+				if err != nil || event != eventChar || char != tt.char {
+					t.Errorf("expected (eventChar, %q), got (%v, %q)", tt.char, event, char)
+				}
+			})
+		}
+	})
+}
+
+func TestRenderSelect(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1", Description: "first item"},
+		{Name: "item2"},
+	}
+
+	t.Run("ShowsPromptAndItems", func(t *testing.T) {
+		s := newSelectState(items)
+		var buf bytes.Buffer
+		lineCount := renderSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "Select:") {
+			t.Error("expected prompt in output")
+		}
+		if !strings.Contains(output, "item1") {
+			t.Error("expected item1 in output")
+		}
+		if !strings.Contains(output, "first item") {
+			t.Error("expected description in output")
+		}
+		if !strings.Contains(output, "item2") {
+			t.Error("expected item2 in output")
+		}
+		if lineCount != 3 { // 1 prompt + 2 items
+			t.Errorf("expected 3 lines, got %d", lineCount)
+		}
+	})
+
+	t.Run("EmptyFilteredList_ShowsNoMatches", func(t *testing.T) {
+		s := newSelectState(items)
+		s.filter = "xyz"
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "no matches") {
+			t.Errorf("expected 'no matches' message, got: %s", output)
+		}
+	})
+
+	t.Run("EmptyFilteredList_EmptyFilter_ShowsNoMatches", func(t *testing.T) {
+		s := newSelectState([]selectItem{})
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "no matches") {
+			t.Error("expected 'no matches' message for empty list with no filter")
+		}
+	})
+
+	t.Run("LongList_ShowsRemainingCount", func(t *testing.T) {
+		manyItems := make([]selectItem, 15)
+		for i := range manyItems {
+			manyItems[i] = selectItem{Name: string(rune('a' + i))}
+		}
+		s := newSelectState(manyItems)
+		var buf bytes.Buffer
+		renderSelect(&buf, "Select:", s)
+
+		// 15 items - 10 displayed = 5 more
+		if !strings.Contains(buf.String(), "5 more") {
+			t.Error("expected '5 more' indicator")
+		}
+	})
+}
+
+func TestRenderMultiSelect(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1"},
+		{Name: "item2"},
+	}
+
+	t.Run("ShowsCheckboxes", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		output := buf.String()
+		if !strings.Contains(output, "[x]") {
+			t.Error("expected checked checkbox [x]")
+		}
+		if !strings.Contains(output, "[ ]") {
+			t.Error("expected unchecked checkbox [ ]")
+		}
+	})
+
+	t.Run("ShowsDefaultMarker", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "(default)") {
+			t.Error("expected (default) marker for first checked item")
+		}
+	})
+
+	t.Run("ShowsSelectedCount", func(t *testing.T) {
+		s := newMultiSelectState(items, []string{"item1", "item2"})
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "2 selected") {
+			t.Error("expected '2 selected' in output")
+		}
+	})
+
+	t.Run("NoSelection_ShowsHelperText", func(t *testing.T) {
+		s := newMultiSelectState(items, nil)
+		var buf bytes.Buffer
+		renderMultiSelect(&buf, "Select:", s)
+
+		if !strings.Contains(buf.String(), "Select at least one") {
+			t.Error("expected 'Select at least one' helper text")
+		}
+	})
+}
+
 func TestErrCancelled(t *testing.T) {
 	t.Run("NotNil", func(t *testing.T) {
 		if errCancelled == nil {
@@ -17,3 +678,255 @@ func TestErrCancelled(t *testing.T) {
 		}
 	})
 }
+
+// Edge case tests for selector.go
+
+// TestSelectState_SingleItem verifies that single item list works without crash.
+// List with only one item should still work.
+func TestSelectState_SingleItem(t *testing.T) {
+	items := []selectItem{{Name: "only-one"}}
+
+	s := newSelectState(items)
+
+	// Down should do nothing (already at bottom)
+	s.handleInput(eventDown, 0)
+	if s.selected != 0 {
+		t.Errorf("down on single item: expected selected=0, got %d", s.selected)
+	}
+
+	// Up should do nothing (already at top)
+	s.handleInput(eventUp, 0)
+	if s.selected != 0 {
+		t.Errorf("up on single item: expected selected=0, got %d", s.selected)
+	}
+
+	// Enter should select the only item
+	done, result, err := s.handleInput(eventEnter, 0)
+	if !done || result != "only-one" || err != nil {
+		t.Errorf("enter on single item: expected (true, 'only-one', nil), got (%v, %q, %v)", done, result, err)
+	}
+}
+
+// TestSelectState_ExactlyMaxItems verifies boundary condition at maxDisplayedItems.
+// List with exactly maxDisplayedItems items should not scroll.
+func TestSelectState_ExactlyMaxItems(t *testing.T) {
+	items := make([]selectItem, maxDisplayedItems)
+	for i := range items {
+		items[i] = selectItem{Name: string(rune('a' + i))}
+	}
+
+	s := newSelectState(items)
+
+	// Move to last item
+	for range maxDisplayedItems - 1 {
+		s.handleInput(eventDown, 0)
+	}
+
+	if s.selected != maxDisplayedItems-1 {
+		t.Errorf("expected selected=%d, got %d", maxDisplayedItems-1, s.selected)
+	}
+
+	// Should not scroll when exactly at max
+	if s.scrollOffset != 0 {
+		t.Errorf("expected scrollOffset=0 for exactly maxDisplayedItems, got %d", s.scrollOffset)
+	}
+
+	// One more down should do nothing
+	s.handleInput(eventDown, 0)
+	if s.selected != maxDisplayedItems-1 {
+		t.Errorf("down at max: expected selected=%d, got %d", maxDisplayedItems-1, s.selected)
+	}
+}
+
+// TestFilterItems_RegexSpecialChars verifies that filter is literal, not regex.
+// User typing "model.v1" shouldn't match "modelsv1".
+func TestFilterItems_RegexSpecialChars(t *testing.T) {
+	items := []selectItem{
+		{Name: "model.v1"},
+		{Name: "modelsv1"},
+		{Name: "model-v1"},
+	}
+
+	// Filter with dot should only match literal dot
+	result := filterItems(items, "model.v1")
+	if len(result) != 1 {
+		t.Errorf("expected 1 exact match, got %d", len(result))
+	}
+	if len(result) > 0 && result[0].Name != "model.v1" {
+		t.Errorf("expected 'model.v1', got %s", result[0].Name)
+	}
+
+	// Other regex special chars should be literal too
+	items2 := []selectItem{
+		{Name: "test[0]"},
+		{Name: "test0"},
+		{Name: "test(1)"},
+	}
+
+	result2 := filterItems(items2, "test[0]")
+	if len(result2) != 1 || result2[0].Name != "test[0]" {
+		t.Errorf("expected only 'test[0]', got %v", result2)
+	}
+}
+
+// TestMultiSelectState_DuplicateNames documents handling of duplicate item names.
+// itemIndex uses name as key - duplicates cause collision. This documents
+// the current behavior: the last index for a duplicate name is stored
+func TestMultiSelectState_DuplicateNames(t *testing.T) {
+	// Duplicate names - this is an edge case that shouldn't happen in practice
+	items := []selectItem{
+		{Name: "duplicate"},
+		{Name: "duplicate"},
+		{Name: "unique"},
+	}
+
+	s := newMultiSelectState(items, nil)
+
+	// DOCUMENTED BEHAVIOR: itemIndex maps name to LAST index
+	// When there are duplicates, only the last occurrence's index is stored
+	if s.itemIndex["duplicate"] != 1 {
+		t.Errorf("itemIndex should map 'duplicate' to last index (1), got %d", s.itemIndex["duplicate"])
+	}
+
+	// Toggle item at highlighted=0 (first "duplicate")
+	// Due to name collision, toggleItem uses itemIndex["duplicate"] = 1
+	// So it actually toggles the SECOND duplicate item, not the first
+	s.toggleItem()
+
+	// This documents the potentially surprising behavior:
+	// We toggled at highlighted=0, but itemIndex lookup returned 1
+	if !s.checked[1] {
+		t.Error("toggle should check index 1 (due to name collision in itemIndex)")
+	}
+	if s.checked[0] {
+		t.Log("Note: index 0 is NOT checked, even though highlighted=0 (name collision behavior)")
+	}
+}
+
+// TestSelectState_FilterReducesBelowSelection verifies selection resets when filter reduces list.
+// Prevents index-out-of-bounds on next keystroke
+func TestSelectState_FilterReducesBelowSelection(t *testing.T) {
+	items := []selectItem{
+		{Name: "apple"},
+		{Name: "banana"},
+		{Name: "cherry"},
+	}
+
+	s := newSelectState(items)
+	s.selected = 2 // Select "cherry"
+
+	// Type a filter that removes cherry from results
+	s.handleInput(eventChar, 'a') // Filter to "a" - matches "apple" and "banana"
+
+	// Selection should reset to 0
+	if s.selected != 0 {
+		t.Errorf("expected selected=0 after filter, got %d", s.selected)
+	}
+
+	filtered := s.filtered()
+	if len(filtered) != 2 {
+		t.Errorf("expected 2 filtered items, got %d", len(filtered))
+	}
+}
+
+// TestFilterItems_UnicodeCharacters verifies filtering works with UTF-8.
+// Model names might contain unicode characters
+func TestFilterItems_UnicodeCharacters(t *testing.T) {
+	items := []selectItem{
+		{Name: "llama-日本語"},
+		{Name: "模型-chinese"},
+		{Name: "émoji-🦙"},
+		{Name: "regular-model"},
+	}
+
+	t.Run("filter japanese", func(t *testing.T) {
+		result := filterItems(items, "日本")
+		if len(result) != 1 || result[0].Name != "llama-日本語" {
+			t.Errorf("expected llama-日本語, got %v", result)
+		}
+	})
+
+	t.Run("filter chinese", func(t *testing.T) {
+		result := filterItems(items, "模型")
+		if len(result) != 1 || result[0].Name != "模型-chinese" {
+			t.Errorf("expected 模型-chinese, got %v", result)
+		}
+	})
+
+	t.Run("filter emoji", func(t *testing.T) {
+		result := filterItems(items, "🦙")
+		if len(result) != 1 || result[0].Name != "émoji-🦙" {
+			t.Errorf("expected émoji-🦙, got %v", result)
+		}
+	})
+
+	t.Run("filter accented char", func(t *testing.T) {
+		result := filterItems(items, "émoji")
+		if len(result) != 1 || result[0].Name != "émoji-🦙" {
+			t.Errorf("expected émoji-🦙, got %v", result)
+		}
+	})
+}
+
+// TestMultiSelectState_FilterReducesBelowHighlight verifies highlight resets when filter reduces list.
+func TestMultiSelectState_FilterReducesBelowHighlight(t *testing.T) {
+	items := []selectItem{
+		{Name: "apple"},
+		{Name: "banana"},
+		{Name: "cherry"},
+	}
+
+	s := newMultiSelectState(items, nil)
+	s.highlighted = 2 // Highlight "cherry"
+
+	// Type a filter that removes cherry
+	s.handleInput(eventChar, 'a')
+
+	if s.highlighted != 0 {
+		t.Errorf("expected highlighted=0 after filter, got %d", s.highlighted)
+	}
+}
+
+// TestMultiSelectState_EmptyItems verifies handling of empty item list.
+// Empty list should be handled gracefully.
+func TestMultiSelectState_EmptyItems(t *testing.T) {
+	s := newMultiSelectState([]selectItem{}, nil)
+
+	// Toggle should not panic on empty list
+	s.toggleItem()
+
+	if s.selectedCount() != 0 {
+		t.Errorf("expected 0 selected for empty list, got %d", s.selectedCount())
+	}
+
+	// Render should handle empty list
+	var buf bytes.Buffer
+	lineCount := renderMultiSelect(&buf, "Select:", s)
+	if lineCount == 0 {
+		t.Error("renderMultiSelect should produce output even for empty list")
+	}
+	if !strings.Contains(buf.String(), "no matches") {
+		t.Error("expected 'no matches' for empty list")
+	}
+}
+
+// TestSelectState_RenderWithDescriptions verifies rendering items with descriptions.
+func TestSelectState_RenderWithDescriptions(t *testing.T) {
+	items := []selectItem{
+		{Name: "item1", Description: "First item description"},
+		{Name: "item2", Description: ""},
+		{Name: "item3", Description: "Third item"},
+	}
+
+	s := newSelectState(items)
+	var buf bytes.Buffer
+	renderSelect(&buf, "Select:", s)
+
+	output := buf.String()
+	if !strings.Contains(output, "First item description") {
+		t.Error("expected description to be rendered")
+	}
+	if !strings.Contains(output, "item2") {
+		t.Error("expected item without description to be rendered")
+	}
+}
--- a/cmd/editor_unix.go
+++ b/cmd/editor_unix.go
@@ -1,5 +0,0 @@
-//go:build !windows
-
-package cmd
-
-const defaultEditor = "vi"
--- a/cmd/editor_windows.go
+++ b/cmd/editor_windows.go
@@ -1,5 +0,0 @@
-//go:build windows
-
-package cmd
-
-const defaultEditor = "edit"
--- a/cmd/interactive.go
+++ b/cmd/interactive.go
@@ -7,7 +7,6 @@ import (
 	"io"
 	"net/http"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"regexp"
 	"slices"
@@ -80,7 +79,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 		fmt.Fprintln(os.Stderr, "  Ctrl + w            Delete the word before the cursor")
 		fmt.Fprintln(os.Stderr, "")
 		fmt.Fprintln(os.Stderr, "  Ctrl + l            Clear the screen")
-		fmt.Fprintln(os.Stderr, "  Ctrl + g            Open default editor to compose a prompt")
 		fmt.Fprintln(os.Stderr, "  Ctrl + c            Stop the model from responding")
 		fmt.Fprintln(os.Stderr, "  Ctrl + d            Exit ollama (/bye)")
 		fmt.Fprintln(os.Stderr, "")
@@ -149,18 +147,6 @@ func generateInteractive(cmd *cobra.Command, opts runOptions) error {
 			scanner.Prompt.UseAlt = false
 			sb.Reset()

-			continue
-		case errors.Is(err, readline.ErrEditPrompt):
-			sb.Reset()
-			content, err := editInExternalEditor(line)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "error: %v\n", err)
-				continue
-			}
-			if strings.TrimSpace(content) == "" {
-				continue
-			}
-			scanner.Prefill = content
 			continue
 		case err != nil:
 			return err
@@ -612,57 +598,6 @@ func extractFileData(input string) (string, []api.ImageData, error) {
 	return strings.TrimSpace(input), imgs, nil
 }

-func editInExternalEditor(content string) (string, error) {
-	editor := envconfig.Editor()
-	if editor == "" {
-		editor = os.Getenv("VISUAL")
-	}
-	if editor == "" {
-		editor = os.Getenv("EDITOR")
-	}
-	if editor == "" {
-		editor = defaultEditor
-	}
-
-	// Check that the editor binary exists
-	name := strings.Fields(editor)[0]
-	if _, err := exec.LookPath(name); err != nil {
-		return "", fmt.Errorf("editor %q not found, set OLLAMA_EDITOR to the path of your preferred editor", name)
-	}
-
-	tmpFile, err := os.CreateTemp("", "ollama-prompt-*.txt")
-	if err != nil {
-		return "", fmt.Errorf("creating temp file: %w", err)
-	}
-	defer os.Remove(tmpFile.Name())
-
-	if content != "" {
-		if _, err := tmpFile.WriteString(content); err != nil {
-			tmpFile.Close()
-			return "", fmt.Errorf("writing to temp file: %w", err)
-		}
-	}
-	tmpFile.Close()
-
-	args := strings.Fields(editor)
-	args = append(args, tmpFile.Name())
-	cmd := exec.Command(args[0], args[1:]...)
-	cmd.Stdin = os.Stdin
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	if err := cmd.Run(); err != nil {
-		return "", fmt.Errorf("editor exited with error: %w", err)
-	}
-
-	data, err := os.ReadFile(tmpFile.Name())
-	if err != nil {
-		return "", fmt.Errorf("reading temp file: %w", err)
-	}
-
-	return strings.TrimRight(string(data), "\n"), nil
-}
-
 func getImageData(filePath string) ([]byte, error) {
 	file, err := os.Open(filePath)
 	if err != nil {
--- a/cmd/tui/confirm.go
+++ b/cmd/tui/confirm.go
@@ -1,109 +0,0 @@
-package tui
-
-import (
-	"fmt"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-)
-
-var (
-	confirmActiveStyle = lipgloss.NewStyle().
-				Bold(true).
-				Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
-
-	confirmInactiveStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
-)
-
-type confirmModel struct {
-	prompt    string
-	yes       bool
-	confirmed bool
-	cancelled bool
-	width     int
-}
-
-func (m confirmModel) Init() tea.Cmd {
-	return nil
-}
-
-func (m confirmModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		wasSet := m.width > 0
-		m.width = msg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-
-	case tea.KeyMsg:
-		switch msg.String() {
-		case "ctrl+c", "esc", "n":
-			m.cancelled = true
-			return m, tea.Quit
-		case "y":
-			m.yes = true
-			m.confirmed = true
-			return m, tea.Quit
-		case "enter":
-			m.confirmed = true
-			return m, tea.Quit
-		case "left", "h":
-			m.yes = true
-		case "right", "l":
-			m.yes = false
-		case "tab":
-			m.yes = !m.yes
-		}
-	}
-
-	return m, nil
-}
-
-func (m confirmModel) View() string {
-	if m.confirmed || m.cancelled {
-		return ""
-	}
-
-	var yesBtn, noBtn string
-	if m.yes {
-		yesBtn = confirmActiveStyle.Render(" Yes ")
-		noBtn = confirmInactiveStyle.Render(" No ")
-	} else {
-		yesBtn = confirmInactiveStyle.Render(" Yes ")
-		noBtn = confirmActiveStyle.Render(" No ")
-	}
-
-	s := selectorTitleStyle.Render(m.prompt) + "\n\n"
-	s += "  " + yesBtn + "  " + noBtn + "\n\n"
-	s += selectorHelpStyle.Render("←/→ navigate • enter confirm • esc cancel")
-
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
-	}
-	return s
-}
-
-// RunConfirm shows a bubbletea yes/no confirmation prompt.
-// Returns true if the user confirmed, false if cancelled.
-func RunConfirm(prompt string) (bool, error) {
-	m := confirmModel{
-		prompt: prompt,
-		yes:    true, // default to yes
-	}
-
-	p := tea.NewProgram(m)
-	finalModel, err := p.Run()
-	if err != nil {
-		return false, fmt.Errorf("error running confirm: %w", err)
-	}
-
-	fm := finalModel.(confirmModel)
-	if fm.cancelled {
-		return false, ErrCancelled
-	}
-
-	return fm.yes, nil
-}
--- a/cmd/tui/confirm_test.go
+++ b/cmd/tui/confirm_test.go
@@ -1,208 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func TestConfirmModel_DefaultsToYes(t *testing.T) {
-	m := confirmModel{prompt: "Download test?", yes: true}
-	if !m.yes {
-		t.Error("should default to yes")
-	}
-}
-
-func TestConfirmModel_View_ContainsPrompt(t *testing.T) {
-	m := confirmModel{prompt: "Download qwen3:8b?", yes: true}
-	got := m.View()
-	if !strings.Contains(got, "Download qwen3:8b?") {
-		t.Error("should contain the prompt text")
-	}
-}
-
-func TestConfirmModel_View_ContainsButtons(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	got := m.View()
-	if !strings.Contains(got, "Yes") {
-		t.Error("should contain Yes button")
-	}
-	if !strings.Contains(got, "No") {
-		t.Error("should contain No button")
-	}
-}
-
-func TestConfirmModel_View_ContainsHelp(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	got := m.View()
-	if !strings.Contains(got, "enter confirm") {
-		t.Error("should contain help text")
-	}
-}
-
-func TestConfirmModel_View_ClearsAfterConfirm(t *testing.T) {
-	m := confirmModel{prompt: "Download?", confirmed: true}
-	if m.View() != "" {
-		t.Error("View should return empty string after confirmation")
-	}
-}
-
-func TestConfirmModel_View_ClearsAfterCancel(t *testing.T) {
-	m := confirmModel{prompt: "Download?", cancelled: true}
-	if m.View() != "" {
-		t.Error("View should return empty string after cancellation")
-	}
-}
-
-func TestConfirmModel_EnterConfirmsYes(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	fm := updated.(confirmModel)
-	if !fm.confirmed {
-		t.Error("enter should set confirmed=true")
-	}
-	if !fm.yes {
-		t.Error("enter with yes selected should keep yes=true")
-	}
-	if cmd == nil {
-		t.Error("enter should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_EnterConfirmsNo(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: false}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEnter})
-	fm := updated.(confirmModel)
-	if !fm.confirmed {
-		t.Error("enter should set confirmed=true")
-	}
-	if fm.yes {
-		t.Error("enter with no selected should keep yes=false")
-	}
-	if cmd == nil {
-		t.Error("enter should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_EscCancels(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
-	fm := updated.(confirmModel)
-	if !fm.cancelled {
-		t.Error("esc should set cancelled=true")
-	}
-	if cmd == nil {
-		t.Error("esc should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_CtrlCCancels(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyCtrlC})
-	fm := updated.(confirmModel)
-	if !fm.cancelled {
-		t.Error("ctrl+c should set cancelled=true")
-	}
-	if cmd == nil {
-		t.Error("ctrl+c should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_NCancels(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'n'}})
-	fm := updated.(confirmModel)
-	if !fm.cancelled {
-		t.Error("'n' should set cancelled=true")
-	}
-	if cmd == nil {
-		t.Error("'n' should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_YConfirmsYes(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: false}
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'y'}})
-	fm := updated.(confirmModel)
-	if !fm.confirmed {
-		t.Error("'y' should set confirmed=true")
-	}
-	if !fm.yes {
-		t.Error("'y' should set yes=true")
-	}
-	if cmd == nil {
-		t.Error("'y' should return tea.Quit")
-	}
-}
-
-func TestConfirmModel_ArrowKeysNavigate(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-
-	// Right moves to No
-	updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'l'}})
-	fm := updated.(confirmModel)
-	if fm.yes {
-		t.Error("right/l should move to No")
-	}
-	if fm.confirmed || fm.cancelled {
-		t.Error("navigation should not confirm or cancel")
-	}
-
-	// Left moves back to Yes
-	updated, _ = fm.Update(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'h'}})
-	fm = updated.(confirmModel)
-	if !fm.yes {
-		t.Error("left/h should move to Yes")
-	}
-}
-
-func TestConfirmModel_TabToggles(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true}
-
-	updated, _ := m.Update(tea.KeyMsg{Type: tea.KeyTab})
-	fm := updated.(confirmModel)
-	if fm.yes {
-		t.Error("tab should toggle from Yes to No")
-	}
-
-	updated, _ = fm.Update(tea.KeyMsg{Type: tea.KeyTab})
-	fm = updated.(confirmModel)
-	if !fm.yes {
-		t.Error("tab should toggle from No to Yes")
-	}
-}
-
-func TestConfirmModel_WindowSizeUpdatesWidth(t *testing.T) {
-	m := confirmModel{prompt: "Download?"}
-	updated, _ := m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
-	fm := updated.(confirmModel)
-	if fm.width != 100 {
-		t.Errorf("expected width 100, got %d", fm.width)
-	}
-}
-
-func TestConfirmModel_ResizeEntersAltScreen(t *testing.T) {
-	m := confirmModel{prompt: "Download?", width: 80}
-	_, cmd := m.Update(tea.WindowSizeMsg{Width: 100, Height: 40})
-	if cmd == nil {
-		t.Error("resize (width already set) should return a command")
-	}
-}
-
-func TestConfirmModel_InitialWindowSizeNoAltScreen(t *testing.T) {
-	m := confirmModel{prompt: "Download?"}
-	_, cmd := m.Update(tea.WindowSizeMsg{Width: 80, Height: 40})
-	if cmd != nil {
-		t.Error("initial WindowSizeMsg should not return a command")
-	}
-}
-
-func TestConfirmModel_ViewMaxWidth(t *testing.T) {
-	m := confirmModel{prompt: "Download?", yes: true, width: 40}
-	got := m.View()
-	// Just ensure it doesn't panic and returns content
-	if got == "" {
-		t.Error("View with width set should still return content")
-	}
-}
--- a/cmd/tui/selector.go
+++ b/cmd/tui/selector.go
@@ -7,7 +7,6 @@ import (

 	tea "github.com/charmbracelet/bubbletea"
 	"github.com/charmbracelet/lipgloss"
-	"github.com/ollama/ollama/cmd/config"
 )

 var (
@@ -19,38 +18,35 @@ var (

 	selectorSelectedItemStyle = lipgloss.NewStyle().
 					PaddingLeft(2).
-					Bold(true).
-					Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
+					Bold(true)

 	selectorDescStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
-
-	selectorDescLineStyle = selectorDescStyle.
-				PaddingLeft(6)
+				Foreground(lipgloss.Color("241"))

 	selectorFilterStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)

 	selectorInputStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "235", Dark: "252"})
+				Foreground(lipgloss.Color("252"))
+
+	selectorCheckboxStyle = lipgloss.NewStyle().
+				Foreground(lipgloss.Color("241"))
+
+	selectorCheckboxCheckedStyle = lipgloss.NewStyle().
+					Bold(true)

 	selectorDefaultTagStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)

 	selectorHelpStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "244", Dark: "244"})
+				Foreground(lipgloss.Color("241"))

 	selectorMoreStyle = lipgloss.NewStyle().
-				PaddingLeft(6).
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				PaddingLeft(4).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
-
-	sectionHeaderStyle = lipgloss.NewStyle().
-				PaddingLeft(2).
-				Bold(true).
-				Foreground(lipgloss.AdaptiveColor{Light: "240", Dark: "249"})
 )

 const maxSelectorItems = 10
@@ -58,34 +54,10 @@ const maxSelectorItems = 10
 // ErrCancelled is returned when the user cancels the selection.
 var ErrCancelled = errors.New("cancelled")

+// SelectItem represents an item that can be selected.
 type SelectItem struct {
 	Name        string
 	Description string
-	Recommended bool
-}
-
-// ConvertItems converts config.ModelItem slice to SelectItem slice.
-func ConvertItems(items []config.ModelItem) []SelectItem {
-	out := make([]SelectItem, len(items))
-	for i, item := range items {
-		out[i] = SelectItem{Name: item.Name, Description: item.Description, Recommended: item.Recommended}
-	}
-	return out
-}
-
-// ReorderItems returns a copy with recommended items first, then non-recommended,
-// preserving relative order within each group. This ensures the data order matches
-// the visual section layout (Recommended / More).
-func ReorderItems(items []SelectItem) []SelectItem {
-	var rec, other []SelectItem
-	for _, item := range items {
-		if item.Recommended {
-			rec = append(rec, item)
-		} else {
-			other = append(other, item)
-		}
-	}
-	return append(rec, other...)
 }

 // selectorModel is the bubbletea model for single selection.
@@ -97,8 +69,6 @@ type selectorModel struct {
 	scrollOffset int
 	selected     string
 	cancelled    bool
-	helpText     string
-	width        int
 }

 func (m selectorModel) filteredItems() []SelectItem {
@@ -119,153 +89,83 @@ func (m selectorModel) Init() tea.Cmd {
 	return nil
 }

-// otherStart returns the index of the first non-recommended item in the filtered list.
-// When filtering, all items scroll together so this returns 0.
-func (m selectorModel) otherStart() int {
-	if m.filter != "" {
-		return 0
-	}
-	filtered := m.filteredItems()
-	for i, item := range filtered {
-		if !item.Recommended {
-			return i
-		}
-	}
-	return len(filtered)
-}
-
-// updateNavigation handles navigation keys (up/down/pgup/pgdown/filter/backspace).
-// It does NOT handle Enter, Esc, or CtrlC. This is used by both the standalone
-// selector and the TUI modal (which intercepts Enter/Esc for its own logic).
-func (m *selectorModel) updateNavigation(msg tea.KeyMsg) {
-	filtered := m.filteredItems()
-	otherStart := m.otherStart()
-
-	switch msg.Type {
-	case tea.KeyUp:
-		if m.cursor > 0 {
-			m.cursor--
-			m.updateScroll(otherStart)
-		}
-
-	case tea.KeyDown:
-		if m.cursor < len(filtered)-1 {
-			m.cursor++
-			m.updateScroll(otherStart)
-		}
-
-	case tea.KeyPgUp:
-		m.cursor -= maxSelectorItems
-		if m.cursor < 0 {
-			m.cursor = 0
-		}
-		m.updateScroll(otherStart)
-
-	case tea.KeyPgDown:
-		m.cursor += maxSelectorItems
-		if m.cursor >= len(filtered) {
-			m.cursor = len(filtered) - 1
-		}
-		m.updateScroll(otherStart)
-
-	case tea.KeyBackspace:
-		if len(m.filter) > 0 {
-			m.filter = m.filter[:len(m.filter)-1]
-			m.cursor = 0
-			m.scrollOffset = 0
-		}
-
-	case tea.KeyRunes:
-		m.filter += string(msg.Runes)
-		m.cursor = 0
-		m.scrollOffset = 0
-	}
-}
-
-// updateScroll adjusts scrollOffset based on cursor position.
-// When not filtering, scrollOffset is relative to the "More" (non-recommended) section.
-// When filtering, it's relative to the full filtered list.
-func (m *selectorModel) updateScroll(otherStart int) {
-	if m.filter != "" {
-		if m.cursor < m.scrollOffset {
-			m.scrollOffset = m.cursor
-		}
-		if m.cursor >= m.scrollOffset+maxSelectorItems {
-			m.scrollOffset = m.cursor - maxSelectorItems + 1
-		}
-		return
-	}
-
-	// Cursor is in recommended section — reset "More" scroll to top
-	if m.cursor < otherStart {
-		m.scrollOffset = 0
-		return
-	}
-
-	// Cursor is in "More" section — scroll relative to others
-	posInOthers := m.cursor - otherStart
-	maxOthers := maxSelectorItems - otherStart
-	if maxOthers < 3 {
-		maxOthers = 3
-	}
-	if posInOthers < m.scrollOffset {
-		m.scrollOffset = posInOthers
-	}
-	if posInOthers >= m.scrollOffset+maxOthers {
-		m.scrollOffset = posInOthers - maxOthers + 1
-	}
-}
-
 func (m selectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		wasSet := m.width > 0
-		m.width = msg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-
 	case tea.KeyMsg:
+		filtered := m.filteredItems()
+
 		switch msg.Type {
 		case tea.KeyCtrlC, tea.KeyEsc:
 			m.cancelled = true
 			return m, tea.Quit

 		case tea.KeyEnter:
-			filtered := m.filteredItems()
 			if len(filtered) > 0 && m.cursor < len(filtered) {
 				m.selected = filtered[m.cursor].Name
 			}
 			return m, tea.Quit

-		default:
-			m.updateNavigation(msg)
+		case tea.KeyUp:
+			if m.cursor > 0 {
+				m.cursor--
+				if m.cursor < m.scrollOffset {
+					m.scrollOffset = m.cursor
+				}
+			}
+
+		case tea.KeyDown:
+			if m.cursor < len(filtered)-1 {
+				m.cursor++
+				if m.cursor >= m.scrollOffset+maxSelectorItems {
+					m.scrollOffset = m.cursor - maxSelectorItems + 1
+				}
+			}
+
+		case tea.KeyPgUp:
+			m.cursor -= maxSelectorItems
+			if m.cursor < 0 {
+				m.cursor = 0
+			}
+			m.scrollOffset -= maxSelectorItems
+			if m.scrollOffset < 0 {
+				m.scrollOffset = 0
+			}
+
+		case tea.KeyPgDown:
+			m.cursor += maxSelectorItems
+			if m.cursor >= len(filtered) {
+				m.cursor = len(filtered) - 1
+			}
+			if m.cursor >= m.scrollOffset+maxSelectorItems {
+				m.scrollOffset = m.cursor - maxSelectorItems + 1
+			}
+
+		case tea.KeyBackspace:
+			if len(m.filter) > 0 {
+				m.filter = m.filter[:len(m.filter)-1]
+				m.cursor = 0
+				m.scrollOffset = 0
+			}
+
+		case tea.KeyRunes:
+			m.filter += string(msg.Runes)
+			m.cursor = 0
+			m.scrollOffset = 0
 		}
 	}

 	return m, nil
 }

-func (m selectorModel) renderItem(s *strings.Builder, item SelectItem, idx int) {
-	if idx == m.cursor {
-		s.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
-	} else {
-		s.WriteString(selectorItemStyle.Render(item.Name))
+func (m selectorModel) View() string {
+	// Clear screen when exiting
+	if m.cancelled || m.selected != "" {
+		return ""
 	}
-	s.WriteString("\n")
-	if item.Description != "" {
-		s.WriteString(selectorDescLineStyle.Render(item.Description))
-		s.WriteString("\n")
-	}
-}

-// renderContent renders the selector content (title, items, help text) without
-// checking the cancelled/selected state. This is used by both View() (standalone mode)
-// and by the TUI modal which embeds a selectorModel.
-func (m selectorModel) renderContent() string {
 	var s strings.Builder

+	// Title with filter
 	s.WriteString(selectorTitleStyle.Render(m.title))
 	s.WriteString(" ")
 	if m.filter == "" {
@@ -280,91 +180,42 @@ func (m selectorModel) renderContent() string {
 	if len(filtered) == 0 {
 		s.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
 		s.WriteString("\n")
-	} else if m.filter != "" {
-		s.WriteString(sectionHeaderStyle.Render("Top Results"))
-		s.WriteString("\n")
-
+	} else {
 		displayCount := min(len(filtered), maxSelectorItems)
+
 		for i := range displayCount {
 			idx := m.scrollOffset + i
 			if idx >= len(filtered) {
 				break
 			}
-			m.renderItem(&s, filtered[idx], idx)
+			item := filtered[idx]
+
+			if idx == m.cursor {
+				s.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
+			} else {
+				s.WriteString(selectorItemStyle.Render(item.Name))
+			}
+
+			if item.Description != "" {
+				s.WriteString(" ")
+				s.WriteString(selectorDescStyle.Render("- " + item.Description))
+			}
+			s.WriteString("\n")
 		}

 		if remaining := len(filtered) - m.scrollOffset - displayCount; remaining > 0 {
 			s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
 			s.WriteString("\n")
 		}
-	} else {
-		// Split into pinned recommended and scrollable others
-		var recItems, otherItems []int
-		for i, item := range filtered {
-			if item.Recommended {
-				recItems = append(recItems, i)
-			} else {
-				otherItems = append(otherItems, i)
-			}
-		}
-
-		// Always render all recommended items (pinned)
-		if len(recItems) > 0 {
-			s.WriteString(sectionHeaderStyle.Render("Recommended"))
-			s.WriteString("\n")
-			for _, idx := range recItems {
-				m.renderItem(&s, filtered[idx], idx)
-			}
-		}
-
-		if len(otherItems) > 0 {
-			s.WriteString("\n")
-			s.WriteString(sectionHeaderStyle.Render("More"))
-			s.WriteString("\n")
-
-			maxOthers := maxSelectorItems - len(recItems)
-			if maxOthers < 3 {
-				maxOthers = 3
-			}
-			displayCount := min(len(otherItems), maxOthers)
-
-			for i := range displayCount {
-				idx := m.scrollOffset + i
-				if idx >= len(otherItems) {
-					break
-				}
-				m.renderItem(&s, filtered[otherItems[idx]], otherItems[idx])
-			}
-
-			if remaining := len(otherItems) - m.scrollOffset - displayCount; remaining > 0 {
-				s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
-				s.WriteString("\n")
-			}
-		}
 	}

 	s.WriteString("\n")
-	help := "↑/↓ navigate • enter select • esc cancel"
-	if m.helpText != "" {
-		help = m.helpText
-	}
-	s.WriteString(selectorHelpStyle.Render(help))
+	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • enter select • esc cancel"))

 	return s.String()
 }

-func (m selectorModel) View() string {
-	if m.cancelled || m.selected != "" {
-		return ""
-	}
-
-	s := m.renderContent()
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
-	}
-	return s
-}
-
+// SelectSingle prompts the user to select a single item from a list.
 func SelectSingle(title string, items []SelectItem) (string, error) {
 	if len(items) == 0 {
 		return "", fmt.Errorf("no items to select from")
@@ -401,7 +252,6 @@ type multiSelectorModel struct {
 	checkOrder   []int
 	cancelled    bool
 	confirmed    bool
-	width        int
 }

 func newMultiSelectorModel(title string, items []SelectItem, preChecked []string) multiSelectorModel {
@@ -440,50 +290,6 @@ func (m multiSelectorModel) filteredItems() []SelectItem {
 	return result
 }

-// otherStart returns the index of the first non-recommended item in the filtered list.
-func (m multiSelectorModel) otherStart() int {
-	if m.filter != "" {
-		return 0
-	}
-	filtered := m.filteredItems()
-	for i, item := range filtered {
-		if !item.Recommended {
-			return i
-		}
-	}
-	return len(filtered)
-}
-
-// updateScroll adjusts scrollOffset for section-based scrolling (matches single-select).
-func (m *multiSelectorModel) updateScroll(otherStart int) {
-	if m.filter != "" {
-		if m.cursor < m.scrollOffset {
-			m.scrollOffset = m.cursor
-		}
-		if m.cursor >= m.scrollOffset+maxSelectorItems {
-			m.scrollOffset = m.cursor - maxSelectorItems + 1
-		}
-		return
-	}
-
-	if m.cursor < otherStart {
-		m.scrollOffset = 0
-		return
-	}
-
-	posInOthers := m.cursor - otherStart
-	maxOthers := maxSelectorItems - otherStart
-	if maxOthers < 3 {
-		maxOthers = 3
-	}
-	if posInOthers < m.scrollOffset {
-		m.scrollOffset = posInOthers
-	}
-	if posInOthers >= m.scrollOffset+maxOthers {
-		m.scrollOffset = posInOthers - maxOthers + 1
-	}
-}
-
 func (m *multiSelectorModel) toggleItem() {
 	filtered := m.filteredItems()
 	if len(filtered) == 0 || m.cursor >= len(filtered) {
@@ -517,14 +323,6 @@ func (m multiSelectorModel) Init() tea.Cmd {

 func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		wasSet := m.width > 0
-		m.width = msg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-
 	case tea.KeyMsg:
 		filtered := m.filteredItems()

@@ -534,24 +332,30 @@ func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			return m, tea.Quit

 		case tea.KeyEnter:
+			// Enter confirms if at least one item is selected
 			if len(m.checkOrder) > 0 {
 				m.confirmed = true
 				return m, tea.Quit
 			}

 		case tea.KeySpace:
+			// Space always toggles selection
 			m.toggleItem()

 		case tea.KeyUp:
 			if m.cursor > 0 {
 				m.cursor--
-				m.updateScroll(m.otherStart())
+				if m.cursor < m.scrollOffset {
+					m.scrollOffset = m.cursor
+				}
 			}

 		case tea.KeyDown:
 			if m.cursor < len(filtered)-1 {
 				m.cursor++
-				m.updateScroll(m.otherStart())
+				if m.cursor >= m.scrollOffset+maxSelectorItems {
+					m.scrollOffset = m.cursor - maxSelectorItems + 1
+				}
 			}

 		case tea.KeyPgUp:
@@ -559,14 +363,19 @@ func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.cursor < 0 {
 				m.cursor = 0
 			}
-			m.updateScroll(m.otherStart())
+			m.scrollOffset -= maxSelectorItems
+			if m.scrollOffset < 0 {
+				m.scrollOffset = 0
+			}

 		case tea.KeyPgDown:
 			m.cursor += maxSelectorItems
 			if m.cursor >= len(filtered) {
 				m.cursor = len(filtered) - 1
 			}
-			m.updateScroll(m.otherStart())
+			if m.cursor >= m.scrollOffset+maxSelectorItems {
+				m.scrollOffset = m.cursor - maxSelectorItems + 1
+			}

 		case tea.KeyBackspace:
 			if len(m.filter) > 0 {
@@ -585,41 +394,15 @@ func (m multiSelectorModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 	return m, nil
 }

-func (m multiSelectorModel) renderMultiItem(s *strings.Builder, item SelectItem, idx int) {
-	origIdx := m.itemIndex[item.Name]
-
-	var check string
-	if m.checked[origIdx] {
-		check = "[x] "
-	} else {
-		check = "[ ] "
-	}
-
-	suffix := ""
-	if len(m.checkOrder) > 0 && m.checkOrder[0] == origIdx {
-		suffix = " " + selectorDefaultTagStyle.Render("(default)")
-	}
-
-	if idx == m.cursor {
-		s.WriteString(selectorSelectedItemStyle.Render("▸ " + check + item.Name))
-	} else {
-		s.WriteString(selectorItemStyle.Render(check + item.Name))
-	}
-	s.WriteString(suffix)
-	s.WriteString("\n")
-	if item.Description != "" {
-		s.WriteString(selectorDescLineStyle.Render(item.Description))
-		s.WriteString("\n")
-	}
-}
-
 func (m multiSelectorModel) View() string {
+	// Clear screen when exiting
 	if m.cancelled || m.confirmed {
 		return ""
 	}

 	var s strings.Builder

+	// Title with filter
 	s.WriteString(selectorTitleStyle.Render(m.title))
 	s.WriteString(" ")
 	if m.filter == "" {
@@ -634,69 +417,51 @@ func (m multiSelectorModel) View() string {
 	if len(filtered) == 0 {
 		s.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
 		s.WriteString("\n")
-	} else if m.filter != "" {
-		// Filtering: flat scroll through all matches
+	} else {
 		displayCount := min(len(filtered), maxSelectorItems)
+
 		for i := range displayCount {
 			idx := m.scrollOffset + i
 			if idx >= len(filtered) {
 				break
 			}
-			m.renderMultiItem(&s, filtered[idx], idx)
+			item := filtered[idx]
+			origIdx := m.itemIndex[item.Name]
+
+			// Checkbox
+			var checkbox string
+			if m.checked[origIdx] {
+				checkbox = selectorCheckboxCheckedStyle.Render("[x]")
+			} else {
+				checkbox = selectorCheckboxStyle.Render("[ ]")
+			}
+
+			// Cursor and name
+			var line string
+			if idx == m.cursor {
+				line = selectorSelectedItemStyle.Render("▸ ") + checkbox + " " + selectorSelectedItemStyle.Render(item.Name)
+			} else {
+				line = "  " + checkbox + " " + item.Name
+			}
+
+			// Default tag
+			if len(m.checkOrder) > 0 && m.checkOrder[0] == origIdx {
+				line += " " + selectorDefaultTagStyle.Render("(default)")
+			}
+
+			s.WriteString(line)
+			s.WriteString("\n")
 		}

 		if remaining := len(filtered) - m.scrollOffset - displayCount; remaining > 0 {
 			s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
 			s.WriteString("\n")
 		}
-	} else {
-		// Split into pinned recommended and scrollable others (matches single-select layout)
-		var recItems, otherItems []int
-		for i, item := range filtered {
-			if item.Recommended {
-				recItems = append(recItems, i)
-			} else {
-				otherItems = append(otherItems, i)
-			}
-		}
-
-		// Always render all recommended items (pinned)
-		if len(recItems) > 0 {
-			s.WriteString(sectionHeaderStyle.Render("Recommended"))
-			s.WriteString("\n")
-			for _, idx := range recItems {
-				m.renderMultiItem(&s, filtered[idx], idx)
-			}
-		}
-
-		if len(otherItems) > 0 {
-			s.WriteString("\n")
-			s.WriteString(sectionHeaderStyle.Render("More"))
-			s.WriteString("\n")
-
-			maxOthers := maxSelectorItems - len(recItems)
-			if maxOthers < 3 {
-				maxOthers = 3
-			}
-			displayCount := min(len(otherItems), maxOthers)
-
-			for i := range displayCount {
-				idx := m.scrollOffset + i
-				if idx >= len(otherItems) {
-					break
-				}
-				m.renderMultiItem(&s, filtered[otherItems[idx]], otherItems[idx])
-			}
-
-			if remaining := len(otherItems) - m.scrollOffset - displayCount; remaining > 0 {
-				s.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
-				s.WriteString("\n")
-			}
-		}
 	}

 	s.WriteString("\n")

+	// Status line
 	count := m.selectedCount()
 	if count == 0 {
 		s.WriteString(selectorDescStyle.Render("  Select at least one model."))
@@ -707,13 +472,10 @@ func (m multiSelectorModel) View() string {

 	s.WriteString(selectorHelpStyle.Render("↑/↓ navigate • space toggle • enter confirm • esc cancel"))

-	result := s.String()
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(result)
-	}
-	return result
+	return s.String()
 }

+// SelectMultiple prompts the user to select multiple items from a list.
 func SelectMultiple(title string, items []SelectItem, preChecked []string) ([]string, error) {
 	if len(items) == 0 {
 		return nil, fmt.Errorf("no items to select from")
--- a/cmd/tui/selector_test.go
+++ b/cmd/tui/selector_test.go
@@ -1,573 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func items(names ...string) []SelectItem {
-	var out []SelectItem
-	for _, n := range names {
-		out = append(out, SelectItem{Name: n})
-	}
-	return out
-}
-
-func recItems(names ...string) []SelectItem {
-	var out []SelectItem
-	for _, n := range names {
-		out = append(out, SelectItem{Name: n, Recommended: true})
-	}
-	return out
-}
-
-func mixedItems() []SelectItem {
-	return []SelectItem{
-		{Name: "rec-a", Recommended: true},
-		{Name: "rec-b", Recommended: true},
-		{Name: "other-1"},
-		{Name: "other-2"},
-		{Name: "other-3"},
-		{Name: "other-4"},
-		{Name: "other-5"},
-		{Name: "other-6"},
-		{Name: "other-7"},
-		{Name: "other-8"},
-		{Name: "other-9"},
-		{Name: "other-10"},
-	}
-}
-
-func TestFilteredItems(t *testing.T) {
-	tests := []struct {
-		name   string
-		items  []SelectItem
-		filter string
-		want   []string
-	}{
-		{
-			name:   "no filter returns all",
-			items:  items("alpha", "beta", "gamma"),
-			filter: "",
-			want:   []string{"alpha", "beta", "gamma"},
-		},
-		{
-			name:   "filter matches substring",
-			items:  items("llama3.2", "qwen3:8b", "llama2"),
-			filter: "llama",
-			want:   []string{"llama3.2", "llama2"},
-		},
-		{
-			name:   "filter is case insensitive",
-			items:  items("Qwen3:8b", "llama3.2"),
-			filter: "QWEN",
-			want:   []string{"Qwen3:8b"},
-		},
-		{
-			name:   "no matches",
-			items:  items("alpha", "beta"),
-			filter: "zzz",
-			want:   nil,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := selectorModel{items: tt.items, filter: tt.filter}
-			got := m.filteredItems()
-			var gotNames []string
-			for _, item := range got {
-				gotNames = append(gotNames, item.Name)
-			}
-			if len(gotNames) != len(tt.want) {
-				t.Fatalf("got %v, want %v", gotNames, tt.want)
-			}
-			for i := range tt.want {
-				if gotNames[i] != tt.want[i] {
-					t.Errorf("index %d: got %q, want %q", i, gotNames[i], tt.want[i])
-				}
-			}
-		})
-	}
-}
-
-func TestOtherStart(t *testing.T) {
-	tests := []struct {
-		name   string
-		items  []SelectItem
-		filter string
-		want   int
-	}{
-		{
-			name:  "all recommended",
-			items: recItems("a", "b", "c"),
-			want:  3,
-		},
-		{
-			name:  "none recommended",
-			items: items("a", "b"),
-			want:  0,
-		},
-		{
-			name: "mixed",
-			items: []SelectItem{
-				{Name: "rec-a", Recommended: true},
-				{Name: "rec-b", Recommended: true},
-				{Name: "other-1"},
-				{Name: "other-2"},
-			},
-			want: 2,
-		},
-		{
-			name:  "empty",
-			items: nil,
-			want:  0,
-		},
-		{
-			name: "filtering returns 0",
-			items: []SelectItem{
-				{Name: "rec-a", Recommended: true},
-				{Name: "other-1"},
-			},
-			filter: "rec",
-			want:   0,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := selectorModel{items: tt.items, filter: tt.filter}
-			if got := m.otherStart(); got != tt.want {
-				t.Errorf("otherStart() = %d, want %d", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestUpdateScroll(t *testing.T) {
-	tests := []struct {
-		name       string
-		cursor     int
-		offset     int
-		otherStart int
-		filter     string
-		wantOffset int
-	}{
-		{
-			name:       "cursor in recommended resets scroll",
-			cursor:     1,
-			offset:     5,
-			otherStart: 3,
-			wantOffset: 0,
-		},
-		{
-			name:       "cursor at start of others",
-			cursor:     2,
-			offset:     0,
-			otherStart: 2,
-			wantOffset: 0,
-		},
-		{
-			name:       "cursor scrolls down in others",
-			cursor:     12,
-			offset:     0,
-			otherStart: 2,
-			wantOffset: 3, // posInOthers=10, maxOthers=8, 10-8+1=3
-		},
-		{
-			name:       "cursor scrolls up in others",
-			cursor:     4,
-			offset:     5,
-			otherStart: 2,
-			wantOffset: 2, // posInOthers=2 < offset=5
-		},
-		{
-			name:       "filter mode standard scroll down",
-			cursor:     12,
-			offset:     0,
-			filter:     "x",
-			otherStart: 0,
-			wantOffset: 3, // 12 - 10 + 1 = 3
-		},
-		{
-			name:       "filter mode standard scroll up",
-			cursor:     2,
-			offset:     5,
-			filter:     "x",
-			otherStart: 0,
-			wantOffset: 2,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := selectorModel{
-				cursor:       tt.cursor,
-				scrollOffset: tt.offset,
-				filter:       tt.filter,
-			}
-			m.updateScroll(tt.otherStart)
-			if m.scrollOffset != tt.wantOffset {
-				t.Errorf("scrollOffset = %d, want %d", m.scrollOffset, tt.wantOffset)
-			}
-		})
-	}
-}
-
-func TestRenderContent_SectionHeaders(t *testing.T) {
-	m := selectorModel{
-		title: "Pick:",
-		items: []SelectItem{
-			{Name: "rec-a", Recommended: true},
-			{Name: "other-1"},
-		},
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "Recommended") {
-		t.Error("should contain 'Recommended' header")
-	}
-	if !strings.Contains(content, "More") {
-		t.Error("should contain 'More' header")
-	}
-}
-
-func TestRenderContent_FilteredHeader(t *testing.T) {
-	m := selectorModel{
-		title:  "Pick:",
-		items:  items("alpha", "beta", "alphabet"),
-		filter: "alpha",
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "Top Results") {
-		t.Error("filtered view should contain 'Top Results' header")
-	}
-	if strings.Contains(content, "Recommended") {
-		t.Error("filtered view should not contain 'Recommended' header")
-	}
-}
-
-func TestRenderContent_NoMatches(t *testing.T) {
-	m := selectorModel{
-		title:  "Pick:",
-		items:  items("alpha"),
-		filter: "zzz",
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "(no matches)") {
-		t.Error("should show '(no matches)' when filter has no results")
-	}
-}
-
-func TestRenderContent_SelectedItemIndicator(t *testing.T) {
-	m := selectorModel{
-		title:  "Pick:",
-		items:  items("alpha", "beta"),
-		cursor: 0,
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "▸") {
-		t.Error("selected item should have ▸ indicator")
-	}
-}
-
-func TestRenderContent_Description(t *testing.T) {
-	m := selectorModel{
-		title: "Pick:",
-		items: []SelectItem{
-			{Name: "alpha", Description: "the first letter"},
-		},
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "the first letter") {
-		t.Error("should render item description")
-	}
-}
-
-func TestRenderContent_PinnedRecommended(t *testing.T) {
-	m := selectorModel{
-		title: "Pick:",
-		items: mixedItems(),
-		// cursor deep in "More" section
-		cursor:       8,
-		scrollOffset: 3,
-	}
-	content := m.renderContent()
-
-	// Recommended items should always be visible (pinned)
-	if !strings.Contains(content, "rec-a") {
-		t.Error("recommended items should always be rendered (pinned)")
-	}
-	if !strings.Contains(content, "rec-b") {
-		t.Error("recommended items should always be rendered (pinned)")
-	}
-}
-
-func TestRenderContent_MoreOverflowIndicator(t *testing.T) {
-	m := selectorModel{
-		title: "Pick:",
-		items: mixedItems(), // 2 rec + 10 other = 12 total, maxSelectorItems=10
-	}
-	content := m.renderContent()
-
-	if !strings.Contains(content, "... and") {
-		t.Error("should show overflow indicator when more items than visible")
-	}
-}
-
-func TestUpdateNavigation_CursorBounds(t *testing.T) {
-	m := selectorModel{
-		items:  items("a", "b", "c"),
-		cursor: 0,
-	}
-
-	// Up at top stays at 0
-	m.updateNavigation(keyMsg(KeyUp))
-	if m.cursor != 0 {
-		t.Errorf("cursor should stay at 0 when pressing up at top, got %d", m.cursor)
-	}
-
-	// Down moves to 1
-	m.updateNavigation(keyMsg(KeyDown))
-	if m.cursor != 1 {
-		t.Errorf("cursor should be 1 after down, got %d", m.cursor)
-	}
-
-	// Down to end
-	m.updateNavigation(keyMsg(KeyDown))
-	m.updateNavigation(keyMsg(KeyDown))
-	if m.cursor != 2 {
-		t.Errorf("cursor should be 2 at bottom, got %d", m.cursor)
-	}
-}
-
-func TestUpdateNavigation_FilterResetsState(t *testing.T) {
-	m := selectorModel{
-		items:        items("alpha", "beta"),
-		cursor:       1,
-		scrollOffset: 5,
-	}
-
-	m.updateNavigation(runeMsg('x'))
-	if m.filter != "x" {
-		t.Errorf("filter should be 'x', got %q", m.filter)
-	}
-	if m.cursor != 0 {
-		t.Errorf("cursor should reset to 0 on filter, got %d", m.cursor)
-	}
-	if m.scrollOffset != 0 {
-		t.Errorf("scrollOffset should reset to 0 on filter, got %d", m.scrollOffset)
-	}
-}
-
-func TestUpdateNavigation_Backspace(t *testing.T) {
-	m := selectorModel{
-		items:  items("alpha"),
-		filter: "abc",
-		cursor: 1,
-	}
-
-	m.updateNavigation(keyMsg(KeyBackspace))
-	if m.filter != "ab" {
-		t.Errorf("filter should be 'ab' after backspace, got %q", m.filter)
-	}
-	if m.cursor != 0 {
-		t.Errorf("cursor should reset to 0 on backspace, got %d", m.cursor)
-	}
-}
-
-// --- ReorderItems ---
-
-func TestReorderItems(t *testing.T) {
-	input := []SelectItem{
-		{Name: "local-1"},
-		{Name: "rec-a", Recommended: true},
-		{Name: "local-2"},
-		{Name: "rec-b", Recommended: true},
-	}
-	got := ReorderItems(input)
-	want := []string{"rec-a", "rec-b", "local-1", "local-2"}
-	for i, item := range got {
-		if item.Name != want[i] {
-			t.Errorf("index %d: got %q, want %q", i, item.Name, want[i])
-		}
-	}
-}
-
-func TestReorderItems_AllRecommended(t *testing.T) {
-	input := recItems("a", "b", "c")
-	got := ReorderItems(input)
-	if len(got) != 3 {
-		t.Fatalf("expected 3 items, got %d", len(got))
-	}
-	for i, item := range got {
-		if item.Name != input[i].Name {
-			t.Errorf("order should be preserved, index %d: got %q, want %q", i, item.Name, input[i].Name)
-		}
-	}
-}
-
-func TestReorderItems_NoneRecommended(t *testing.T) {
-	input := items("x", "y")
-	got := ReorderItems(input)
-	if len(got) != 2 || got[0].Name != "x" || got[1].Name != "y" {
-		t.Errorf("order should be preserved, got %v", got)
-	}
-}
-
-// --- Multi-select otherStart ---
-
-func TestMultiOtherStart(t *testing.T) {
-	tests := []struct {
-		name   string
-		items  []SelectItem
-		filter string
-		want   int
-	}{
-		{"all recommended", recItems("a", "b"), "", 2},
-		{"none recommended", items("a", "b"), "", 0},
-		{"mixed", mixedItems(), "", 2},
-		{"with filter returns 0", mixedItems(), "other", 0},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := newMultiSelectorModel("test", tt.items, nil)
-			m.filter = tt.filter
-			if got := m.otherStart(); got != tt.want {
-				t.Errorf("otherStart() = %d, want %d", got, tt.want)
-			}
-		})
-	}
-}
-
-// --- Multi-select updateScroll ---
-
-func TestMultiUpdateScroll(t *testing.T) {
-	tests := []struct {
-		name       string
-		cursor     int
-		offset     int
-		otherStart int
-		wantOffset int
-	}{
-		{"cursor in recommended resets scroll", 1, 5, 3, 0},
-		{"cursor at start of others", 2, 0, 2, 0},
-		{"cursor scrolls down in others", 12, 0, 2, 3},
-		{"cursor scrolls up in others", 4, 5, 2, 2},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			m := newMultiSelectorModel("test", nil, nil)
-			m.cursor = tt.cursor
-			m.scrollOffset = tt.offset
-			m.updateScroll(tt.otherStart)
-			if m.scrollOffset != tt.wantOffset {
-				t.Errorf("scrollOffset = %d, want %d", m.scrollOffset, tt.wantOffset)
-			}
-		})
-	}
-}
-
-// --- Multi-select View section headers ---
-
-func TestMultiView_SectionHeaders(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", []SelectItem{
-		{Name: "rec-a", Recommended: true},
-		{Name: "other-1"},
-	}, nil)
-	content := m.View()
-
-	if !strings.Contains(content, "Recommended") {
-		t.Error("should contain 'Recommended' header")
-	}
-	if !strings.Contains(content, "More") {
-		t.Error("should contain 'More' header")
-	}
-}
-
-func TestMultiView_CursorIndicator(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", items("a", "b"), nil)
-	m.cursor = 0
-	content := m.View()
-
-	if !strings.Contains(content, "▸") {
-		t.Error("should show ▸ cursor indicator")
-	}
-}
-
-func TestMultiView_CheckedItemShowsX(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", items("a", "b"), []string{"a"})
-	content := m.View()
-
-	if !strings.Contains(content, "[x]") {
-		t.Error("checked item should show [x]")
-	}
-	if !strings.Contains(content, "[ ]") {
-		t.Error("unchecked item should show [ ]")
-	}
-}
-
-func TestMultiView_DefaultTag(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", items("a", "b"), []string{"a"})
-	content := m.View()
-
-	if !strings.Contains(content, "(default)") {
-		t.Error("first checked item should have (default) tag")
-	}
-}
-
-func TestMultiView_PinnedRecommended(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", mixedItems(), nil)
-	m.cursor = 8
-	m.scrollOffset = 3
-	content := m.View()
-
-	if !strings.Contains(content, "rec-a") {
-		t.Error("recommended items should always be visible (pinned)")
-	}
-	if !strings.Contains(content, "rec-b") {
-		t.Error("recommended items should always be visible (pinned)")
-	}
-}
-
-func TestMultiView_OverflowIndicator(t *testing.T) {
-	m := newMultiSelectorModel("Pick:", mixedItems(), nil)
-	content := m.View()
-
-	if !strings.Contains(content, "... and") {
-		t.Error("should show overflow indicator when more items than visible")
-	}
-}
-
-// Key message helpers for testing
-
-type keyType = int
-
-const (
-	KeyUp        keyType = iota
-	KeyDown      keyType = iota
-	KeyBackspace keyType = iota
-)
-
-func keyMsg(k keyType) tea.KeyMsg {
-	switch k {
-	case KeyUp:
-		return tea.KeyMsg{Type: tea.KeyUp}
-	case KeyDown:
-		return tea.KeyMsg{Type: tea.KeyDown}
-	case KeyBackspace:
-		return tea.KeyMsg{Type: tea.KeyBackspace}
-	default:
-		return tea.KeyMsg{}
-	}
-}
-
-func runeMsg(r rune) tea.KeyMsg {
-	return tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{r}}
-}
--- a/cmd/tui/signin.go
+++ b/cmd/tui/signin.go
@@ -1,128 +0,0 @@
-package tui
-
-import (
-	"fmt"
-	"strings"
-	"time"
-
-	tea "github.com/charmbracelet/bubbletea"
-	"github.com/charmbracelet/lipgloss"
-	"github.com/ollama/ollama/cmd/config"
-)
-
-type signInModel struct {
-	modelName string
-	signInURL string
-	spinner   int
-	width     int
-	userName  string
-	cancelled bool
-}
-
-func (m signInModel) Init() tea.Cmd {
-	return tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
-		return signInTickMsg{}
-	})
-}
-
-func (m signInModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	switch msg := msg.(type) {
-	case tea.WindowSizeMsg:
-		wasSet := m.width > 0
-		m.width = msg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-
-	case tea.KeyMsg:
-		switch msg.Type {
-		case tea.KeyCtrlC, tea.KeyEsc:
-			m.cancelled = true
-			return m, tea.Quit
-		}
-
-	case signInTickMsg:
-		m.spinner++
-		if m.spinner%5 == 0 {
-			return m, tea.Batch(
-				tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
-					return signInTickMsg{}
-				}),
-				checkSignIn,
-			)
-		}
-		return m, tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
-			return signInTickMsg{}
-		})
-
-	case signInCheckMsg:
-		if msg.signedIn {
-			m.userName = msg.userName
-			return m, tea.Quit
-		}
-	}
-
-	return m, nil
-}
-
-func (m signInModel) View() string {
-	if m.userName != "" {
-		return ""
-	}
-	return renderSignIn(m.modelName, m.signInURL, m.spinner, m.width)
-}
-
-func renderSignIn(modelName, signInURL string, spinner, width int) string {
-	spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
-	frame := spinnerFrames[spinner%len(spinnerFrames)]
-
-	urlColor := lipgloss.NewStyle().
-		Foreground(lipgloss.Color("117"))
-	urlWrap := lipgloss.NewStyle().PaddingLeft(2)
-	if width > 4 {
-		urlWrap = urlWrap.Width(width - 4)
-	}
-
-	var s strings.Builder
-
-	fmt.Fprintf(&s, "To use %s, please sign in.\n\n", selectorSelectedItemStyle.Render(modelName))
-
-	// Wrap in OSC 8 hyperlink so the entire URL is clickable even when wrapped.
-	// Padding is outside the hyperlink so spaces don't get underlined.
-	link := fmt.Sprintf("\033]8;;%s\033\\%s\033]8;;\033\\", signInURL, urlColor.Render(signInURL))
-	s.WriteString("Navigate to:\n")
-	s.WriteString(urlWrap.Render(link))
-	s.WriteString("\n\n")
-
-	s.WriteString(lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).Render(
-		frame + " Waiting for sign in to complete..."))
-	s.WriteString("\n\n")
-
-	s.WriteString(selectorHelpStyle.Render("esc cancel"))
-
-	return lipgloss.NewStyle().PaddingLeft(2).Render(s.String())
-}
-
-// RunSignIn shows a bubbletea sign-in dialog and polls until the user signs in or cancels.
-func RunSignIn(modelName, signInURL string) (string, error) {
-	config.OpenBrowser(signInURL)
-
-	m := signInModel{
-		modelName: modelName,
-		signInURL: signInURL,
-	}
-
-	p := tea.NewProgram(m)
-	finalModel, err := p.Run()
-	if err != nil {
-		return "", fmt.Errorf("error running sign-in: %w", err)
-	}
-
-	fm := finalModel.(signInModel)
-	if fm.cancelled {
-		return "", ErrCancelled
-	}
-
-	return fm.userName, nil
-}
--- a/cmd/tui/signin_test.go
+++ b/cmd/tui/signin_test.go
@@ -1,175 +0,0 @@
-package tui
-
-import (
-	"strings"
-	"testing"
-
-	tea "github.com/charmbracelet/bubbletea"
-)
-
-func TestRenderSignIn_ContainsModelName(t *testing.T) {
-	got := renderSignIn("glm-4.7:cloud", "https://example.com/signin", 0, 80)
-	if !strings.Contains(got, "glm-4.7:cloud") {
-		t.Error("should contain model name")
-	}
-	if !strings.Contains(got, "please sign in") {
-		t.Error("should contain sign-in prompt")
-	}
-}
-
-func TestRenderSignIn_ContainsURL(t *testing.T) {
-	url := "https://ollama.com/connect?key=abc123"
-	got := renderSignIn("test:cloud", url, 0, 120)
-	if !strings.Contains(got, url) {
-		t.Errorf("should contain URL %q", url)
-	}
-}
-
-func TestRenderSignIn_OSC8Hyperlink(t *testing.T) {
-	url := "https://ollama.com/connect?key=abc123"
-	got := renderSignIn("test:cloud", url, 0, 120)
-
-	// Should contain OSC 8 open sequence with the URL
-	osc8Open := "\033]8;;" + url + "\033\\"
-	if !strings.Contains(got, osc8Open) {
-		t.Error("should contain OSC 8 open sequence with URL")
-	}
-
-	// Should contain OSC 8 close sequence
-	osc8Close := "\033]8;;\033\\"
-	if !strings.Contains(got, osc8Close) {
-		t.Error("should contain OSC 8 close sequence")
-	}
-}
-
-func TestRenderSignIn_ContainsSpinner(t *testing.T) {
-	got := renderSignIn("test:cloud", "https://example.com", 0, 80)
-	if !strings.Contains(got, "Waiting for sign in to complete") {
-		t.Error("should contain waiting message")
-	}
-	if !strings.Contains(got, "⠋") {
-		t.Error("should contain first spinner frame at spinner=0")
-	}
-}
-
-func TestRenderSignIn_SpinnerAdvances(t *testing.T) {
-	got0 := renderSignIn("test:cloud", "https://example.com", 0, 80)
-	got1 := renderSignIn("test:cloud", "https://example.com", 1, 80)
-	if got0 == got1 {
-		t.Error("different spinner values should produce different output")
-	}
-}
-
-func TestRenderSignIn_ContainsEscHelp(t *testing.T) {
-	got := renderSignIn("test:cloud", "https://example.com", 0, 80)
-	if !strings.Contains(got, "esc cancel") {
-		t.Error("should contain esc cancel help text")
-	}
-}
-
-func TestSignInModel_EscCancels(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-	}
-
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyEsc})
-	fm := updated.(signInModel)
-	if !fm.cancelled {
-		t.Error("esc should set cancelled=true")
-	}
-	if cmd == nil {
-		t.Error("esc should return tea.Quit")
-	}
-}
-
-func TestSignInModel_CtrlCCancels(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-	}
-
-	updated, cmd := m.Update(tea.KeyMsg{Type: tea.KeyCtrlC})
-	fm := updated.(signInModel)
-	if !fm.cancelled {
-		t.Error("ctrl+c should set cancelled=true")
-	}
-	if cmd == nil {
-		t.Error("ctrl+c should return tea.Quit")
-	}
-}
-
-func TestSignInModel_SignedInQuitsClean(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-	}
-
-	updated, cmd := m.Update(signInCheckMsg{signedIn: true, userName: "alice"})
-	fm := updated.(signInModel)
-	if fm.userName != "alice" {
-		t.Errorf("expected userName 'alice', got %q", fm.userName)
-	}
-	if cmd == nil {
-		t.Error("successful sign-in should return tea.Quit")
-	}
-}
-
-func TestSignInModel_SignedInViewClears(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-		userName:  "alice",
-	}
-
-	got := m.View()
-	if got != "" {
-		t.Errorf("View should return empty string after sign-in, got %q", got)
-	}
-}
-
-func TestSignInModel_NotSignedInContinues(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-	}
-
-	updated, _ := m.Update(signInCheckMsg{signedIn: false})
-	fm := updated.(signInModel)
-	if fm.userName != "" {
-		t.Error("should not set userName when not signed in")
-	}
-	if fm.cancelled {
-		t.Error("should not cancel when check returns not signed in")
-	}
-}
-
-func TestSignInModel_WindowSizeUpdatesWidth(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-	}
-
-	updated, _ := m.Update(tea.WindowSizeMsg{Width: 120, Height: 40})
-	fm := updated.(signInModel)
-	if fm.width != 120 {
-		t.Errorf("expected width 120, got %d", fm.width)
-	}
-}
-
-func TestSignInModel_TickAdvancesSpinner(t *testing.T) {
-	m := signInModel{
-		modelName: "test:cloud",
-		signInURL: "https://example.com",
-		spinner:   0,
-	}
-
-	updated, cmd := m.Update(signInTickMsg{})
-	fm := updated.(signInModel)
-	if fm.spinner != 1 {
-		t.Errorf("expected spinner=1, got %d", fm.spinner)
-	}
-	if cmd == nil {
-		t.Error("tick should return a command")
-	}
-}
--- a/cmd/tui/tui.go
+++ b/cmd/tui/tui.go
@@ -4,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"os/exec"
+	"runtime"
 	"strings"
 	"time"

@@ -15,30 +17,37 @@ import (
 )

 var (
-	versionStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
+	titleStyle = lipgloss.NewStyle().
+			Bold(true).
+			MarginBottom(1)

-	menuItemStyle = lipgloss.NewStyle().
+	versionStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.Color("245"))
+
+	itemStyle = lipgloss.NewStyle().
 			PaddingLeft(2)

-	menuSelectedItemStyle = lipgloss.NewStyle().
-				Bold(true).
-				Background(lipgloss.AdaptiveColor{Light: "254", Dark: "236"})
+	selectedStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			Bold(true)

-	menuDescStyle = selectorDescStyle.
-			PaddingLeft(4)
+	greyedStyle = lipgloss.NewStyle().
+			PaddingLeft(2).
+			Foreground(lipgloss.Color("241"))

-	greyedStyle = menuItemStyle.
-			Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+	greyedSelectedStyle = lipgloss.NewStyle().
+				PaddingLeft(2).
+				Foreground(lipgloss.Color("243"))

-	greyedSelectedStyle = menuSelectedItemStyle.
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"})
+	descStyle = lipgloss.NewStyle().
+			PaddingLeft(4).
+			Foreground(lipgloss.Color("241"))

 	modelStyle = lipgloss.NewStyle().
-			Foreground(lipgloss.AdaptiveColor{Light: "243", Dark: "250"})
+			Foreground(lipgloss.Color("245"))

 	notInstalledStyle = lipgloss.NewStyle().
-				Foreground(lipgloss.AdaptiveColor{Light: "242", Dark: "246"}).
+				Foreground(lipgloss.Color("241")).
 				Italic(true)
 )

@@ -46,106 +55,94 @@ type menuItem struct {
 	title       string
 	description string
 	integration string // integration name for loading model config, empty if not an integration
-	isRunModel  bool
-	isOthers    bool
+	isRunModel  bool   // true for the "Run a model" option
+	isOthers    bool   // true for the "Others..." toggle item
 }

 var mainMenuItems = []menuItem{
 	{
 		title:       "Run a model",
-		description: "Start an interactive chat with a model",
+		description: "Start an interactive chat with a local model",
 		isRunModel:  true,
 	},
 	{
 		title:       "Launch Claude Code",
-		description: "Agentic coding across large codebases",
+		description: "Open Claude Code AI assistant",
 		integration: "claude",
 	},
 	{
 		title:       "Launch Codex",
-		description: "OpenAI's open-source coding agent",
+		description: "Open Codex CLI",
 		integration: "codex",
 	},
 	{
-		title:       "Launch OpenClaw",
-		description: "Personal AI with 100+ skills",
+		title:       "Launch Open Claw",
+		description: "Open the Open Claw integration",
 		integration: "openclaw",
 	},
 }

 var othersMenuItem = menuItem{
-	title:       "More...",
+	title:       "Others...",
 	description: "Show additional integrations",
 	isOthers:    true,
 }

-// getOtherIntegrations dynamically builds the "Others" list from the integration
-// registry, excluding any integrations already present in the pinned mainMenuItems.
+// getOtherIntegrations returns the list of other integrations, filtering out
+// Codex if it's not installed (since it requires npm install).
 func getOtherIntegrations() []menuItem {
-	pinned := map[string]bool{
-		"run": true, // not an integration but in the pinned list
+	return []menuItem{
+		{
+			title:       "Launch Droid",
+			description: "Open Droid integration",
+			integration: "droid",
+		},
+		{
+			title:       "Launch Open Code",
+			description: "Open Open Code integration",
+			integration: "opencode",
+		},
+		{
+			title:       "Launch Pi",
+			description: "Open Pi coding agent",
+			integration: "pi",
+		},
 	}
-	for _, item := range mainMenuItems {
-		if item.integration != "" {
-			pinned[item.integration] = true
-		}
-	}
-
-	var others []menuItem
-	for _, info := range config.ListIntegrationInfos() {
-		if pinned[info.Name] {
-			continue
-		}
-		desc := info.Description
-		if desc == "" {
-			desc = "Open " + info.DisplayName + " integration"
-		}
-		others = append(others, menuItem{
-			title:       "Launch " + info.DisplayName,
-			description: desc,
-			integration: info.Name,
-		})
-	}
-	return others
 }

 type model struct {
 	items           []menuItem
 	cursor          int
 	quitting        bool
-	selected        bool
-	changeModel     bool
-	changeModels    []string // multi-select result for Editor integrations
-	showOthers      bool
-	availableModels map[string]bool
+	selected        bool            // true if user made a selection (enter/space)
+	changeModel     bool            // true if user pressed right arrow to change model
+	showOthers      bool            // true if "Others..." is expanded
+	availableModels map[string]bool // cache of available model names
 	err             error

-	showingModal  bool
-	modalSelector selectorModel
-	modalItems    []SelectItem
+	// Modal state
+	showingModal  bool          // true when model picker modal is visible
+	modalSelector selectorModel // the selector model for the modal
+	modalItems    []SelectItem  // cached items for the modal

-	showingMultiModal  bool
-	multiModalSelector multiSelectorModel
-
-	showingSignIn   bool
-	signInURL       string
-	signInModel     string
-	signInSpinner   int
-	signInFromModal bool // true if sign-in was triggered from modal (not main menu)
-
-	width     int    // terminal width from WindowSizeMsg
-	statusMsg string // temporary status message shown near help text
+	// Sign-in dialog state
+	showingSignIn   bool   // true when sign-in dialog is visible
+	signInURL       string // URL for sign-in
+	signInModel     string // model that requires sign-in
+	signInSpinner   int    // spinner frame index
+	signInFromModal bool   // true if sign-in was triggered from modal (not main menu)
 }

+// signInTickMsg is sent to animate the sign-in spinner
 type signInTickMsg struct{}

+// signInCheckMsg is sent to check if sign-in is complete
 type signInCheckMsg struct {
 	signedIn bool
 	userName string
 }

-type clearStatusMsg struct{}
-
+// modelExists checks if a model exists in the cached available models.
 func (m *model) modelExists(name string) bool {
 	if m.availableModels == nil || name == "" {
 		return false
@@ -162,73 +159,29 @@ func (m *model) modelExists(name string) bool {
 	return false
 }

+// buildModalItems creates the list of models for the modal selector.
 func (m *model) buildModalItems() []SelectItem {
 	modelItems, _ := config.GetModelItems(context.Background())
-	return ReorderItems(ConvertItems(modelItems))
+	var items []SelectItem
+	for _, item := range modelItems {
+		items = append(items, SelectItem{Name: item.Name, Description: item.Description})
+	}
+	return items
 }

-func (m *model) openModelModal(currentModel string) {
+// openModelModal opens the model picker modal.
+func (m *model) openModelModal() {
 	m.modalItems = m.buildModalItems()
-	cursor := 0
-	if currentModel != "" {
-		for i, item := range m.modalItems {
-			if item.Name == currentModel || strings.HasPrefix(item.Name, currentModel+":") || strings.HasPrefix(currentModel, item.Name+":") {
-				cursor = i
-				break
-			}
-		}
-	}
 	m.modalSelector = selectorModel{
-		title:    "Select model:",
-		items:    m.modalItems,
-		cursor:   cursor,
-		helpText: "↑/↓ navigate • enter select • ← back",
+		title: "Select model:",
+		items: m.modalItems,
 	}
-	m.modalSelector.updateScroll(m.modalSelector.otherStart())
 	m.showingModal = true
 }

-func (m *model) openMultiModelModal(integration string) {
-	items := m.buildModalItems()
-	var preChecked []string
-	if models := config.IntegrationModels(integration); len(models) > 0 {
-		preChecked = models
-	}
-	m.multiModalSelector = newMultiSelectorModel("Select models:", items, preChecked)
-	// Set cursor to the first pre-checked (last used) model
-	if len(preChecked) > 0 {
-		for i, item := range items {
-			if item.Name == preChecked[0] {
-				m.multiModalSelector.cursor = i
-				m.multiModalSelector.updateScroll(m.multiModalSelector.otherStart())
-				break
-			}
-		}
-	}
-	m.showingMultiModal = true
-}
-
+// isCloudModel returns true if the model name indicates a cloud model.
 func isCloudModel(name string) bool {
-	return strings.HasSuffix(name, ":cloud") || strings.HasSuffix(name, "-cloud")
-}
-
-func cloudStatusDisabled(client *api.Client) bool {
-	status, err := client.CloudStatusExperimental(context.Background())
-	if err != nil {
-		return false
-	}
-	return status.Cloud.Disabled
-}
-
-func cloudModelDisabled(name string) bool {
-	if !isCloudModel(name) {
-		return false
-	}
-	client, err := api.ClientFromEnvironment()
-	if err != nil {
-		return false
-	}
-	return cloudStatusDisabled(client)
+	return strings.HasSuffix(name, ":cloud")
 }

 // checkCloudSignIn checks if a cloud model needs sign-in.
@@ -241,12 +194,9 @@ func (m *model) checkCloudSignIn(modelName string, fromModal bool) tea.Cmd {
 	if err != nil {
 		return nil
 	}
-	if cloudStatusDisabled(client) {
-		return nil
-	}
 	user, err := client.Whoami(context.Background())
 	if err == nil && user != nil && user.Name != "" {
-		return nil
+		return nil // Already signed in
 	}
 	var aErr api.AuthorizationError
 	if errors.As(err, &aErr) && aErr.SigninURL != "" {
@@ -265,13 +215,23 @@ func (m *model) startSignIn(modelName, signInURL string, fromModal bool) tea.Cmd
 	m.signInSpinner = 0
 	m.signInFromModal = fromModal

-	config.OpenBrowser(signInURL)
+	// Open browser (best effort)
+	switch runtime.GOOS {
+	case "darwin":
+		_ = exec.Command("open", signInURL).Start()
+	case "linux":
+		_ = exec.Command("xdg-open", signInURL).Start()
+	case "windows":
+		_ = exec.Command("rundll32", "url.dll,FileProtocolHandler", signInURL).Start()
+	}

+	// Start the spinner tick
 	return tea.Tick(200*time.Millisecond, func(t time.Time) tea.Msg {
 		return signInTickMsg{}
 	})
 }

+// checkSignIn checks if the user has completed sign-in.
 func checkSignIn() tea.Msg {
 	client, err := api.ClientFromEnvironment()
 	if err != nil {
@@ -284,6 +244,7 @@ func checkSignIn() tea.Msg {
 	return signInCheckMsg{signedIn: false}
 }

+// loadAvailableModels fetches and caches the list of available models.
 func (m *model) loadAvailableModels() {
 	m.availableModels = make(map[string]bool)
 	client, err := api.ClientFromEnvironment()
@@ -294,11 +255,7 @@ func (m *model) loadAvailableModels() {
 	if err != nil {
 		return
 	}
-	cloudDisabled := cloudStatusDisabled(client)
 	for _, mdl := range models.Models {
-		if cloudDisabled && mdl.RemoteModel != "" {
-			continue
-		}
 		m.availableModels[mdl.Name] = true
 	}
 }
@@ -309,17 +266,24 @@ func (m *model) buildItems() {
 	m.items = append(m.items, mainMenuItems...)

 	if m.showOthers {
+		// Change "Others..." to "Hide others..."
+		hideItem := menuItem{
+			title:       "Hide others...",
+			description: "Hide additional integrations",
+			isOthers:    true,
+		}
+		m.items = append(m.items, hideItem)
 		m.items = append(m.items, others...)
 	} else {
 		m.items = append(m.items, othersMenuItem)
 	}
 }

+// isOthersIntegration returns true if the integration is in the "Others" menu
 func isOthersIntegration(name string) bool {
-	for _, item := range getOtherIntegrations() {
-		if item.integration == name {
-			return true
-		}
+	switch name {
+	case "droid", "opencode":
+		return true
 	}
 	return false
 }
@@ -330,6 +294,7 @@ func initialModel() model {
 	}
 	m.loadAvailableModels()

+	// Check last selection to determine if we need to expand "Others"
 	lastSelection := config.LastSelection()
 	if isOthersIntegration(lastSelection) {
 		m.showOthers = true
@@ -337,6 +302,7 @@ func initialModel() model {

 	m.buildItems()

+	// Position cursor on last selection
 	if lastSelection != "" {
 		for i, item := range m.items {
 			if lastSelection == "run" && item.isRunModel {
@@ -357,29 +323,18 @@ func (m model) Init() tea.Cmd {
 }

 func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
-	if wmsg, ok := msg.(tea.WindowSizeMsg); ok {
-		wasSet := m.width > 0
-		m.width = wmsg.Width
-		if wasSet {
-			return m, tea.EnterAltScreen
-		}
-		return m, nil
-	}
-
-	if _, ok := msg.(clearStatusMsg); ok {
-		m.statusMsg = ""
-		return m, nil
-	}
-
+	// Handle sign-in dialog
 	if m.showingSignIn {
 		switch msg := msg.(type) {
 		case tea.KeyMsg:
 			switch msg.Type {
 			case tea.KeyCtrlC, tea.KeyEsc:
+				// Cancel sign-in and go back
 				m.showingSignIn = false
 				if m.signInFromModal {
 					m.showingModal = true
 				}
+				// If from main menu, just return to main menu (default state)
 				return m, nil
 			}

@@ -400,10 +355,13 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

 		case signInCheckMsg:
 			if msg.signedIn {
+				// Sign-in complete - proceed with selection
 				if m.signInFromModal {
+					// Came from modal - set changeModel
 					m.modalSelector.selected = m.signInModel
 					m.changeModel = true
 				} else {
+					// Came from main menu - just select
 					m.selected = true
 				}
 				m.quitting = true
@@ -413,44 +371,13 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m, nil
 	}

-	if m.showingMultiModal {
-		switch msg := msg.(type) {
-		case tea.KeyMsg:
-			if msg.Type == tea.KeyLeft {
-				m.showingMultiModal = false
-				return m, nil
-			}
-			updated, cmd := m.multiModalSelector.Update(msg)
-			m.multiModalSelector = updated.(multiSelectorModel)
-
-			if m.multiModalSelector.cancelled {
-				m.showingMultiModal = false
-				return m, nil
-			}
-			if m.multiModalSelector.confirmed {
-				var selected []string
-				for _, idx := range m.multiModalSelector.checkOrder {
-					selected = append(selected, m.multiModalSelector.items[idx].Name)
-				}
-				if len(selected) > 0 {
-					m.changeModels = selected
-					m.changeModel = true
-					m.quitting = true
-					return m, tea.Quit
-				}
-				m.multiModalSelector.confirmed = false
-				return m, nil
-			}
-			return m, cmd
-		}
-		return m, nil
-	}
-
+	// Handle modal input if modal is showing
 	if m.showingModal {
 		switch msg := msg.(type) {
 		case tea.KeyMsg:
 			switch msg.Type {
-			case tea.KeyCtrlC, tea.KeyEsc, tea.KeyLeft:
+			case tea.KeyCtrlC, tea.KeyEsc:
+				// Close modal without selection
 				m.showingModal = false
 				return m, nil

@@ -463,15 +390,63 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 					if cmd := m.checkCloudSignIn(m.modalSelector.selected, true); cmd != nil {
 						return m, cmd
 					}
+					// Selection made - exit with changeModel
 					m.changeModel = true
 					m.quitting = true
 					return m, tea.Quit
 				}
 				return m, nil

-			default:
-				// Delegate navigation (up/down/pgup/pgdown/filter/backspace) to selectorModel
-				m.modalSelector.updateNavigation(msg)
+			case tea.KeyUp:
+				if m.modalSelector.cursor > 0 {
+					m.modalSelector.cursor--
+					if m.modalSelector.cursor < m.modalSelector.scrollOffset {
+						m.modalSelector.scrollOffset = m.modalSelector.cursor
+					}
+				}
+
+			case tea.KeyDown:
+				filtered := m.modalSelector.filteredItems()
+				if m.modalSelector.cursor < len(filtered)-1 {
+					m.modalSelector.cursor++
+					if m.modalSelector.cursor >= m.modalSelector.scrollOffset+maxSelectorItems {
+						m.modalSelector.scrollOffset = m.modalSelector.cursor - maxSelectorItems + 1
+					}
+				}
+
+			case tea.KeyPgUp:
+				filtered := m.modalSelector.filteredItems()
+				m.modalSelector.cursor -= maxSelectorItems
+				if m.modalSelector.cursor < 0 {
+					m.modalSelector.cursor = 0
+				}
+				m.modalSelector.scrollOffset -= maxSelectorItems
+				if m.modalSelector.scrollOffset < 0 {
+					m.modalSelector.scrollOffset = 0
+				}
+				_ = filtered // suppress unused warning
+
+			case tea.KeyPgDown:
+				filtered := m.modalSelector.filteredItems()
+				m.modalSelector.cursor += maxSelectorItems
+				if m.modalSelector.cursor >= len(filtered) {
+					m.modalSelector.cursor = len(filtered) - 1
+				}
+				if m.modalSelector.cursor >= m.modalSelector.scrollOffset+maxSelectorItems {
+					m.modalSelector.scrollOffset = m.modalSelector.cursor - maxSelectorItems + 1
+				}
+
+			case tea.KeyBackspace:
+				if len(m.modalSelector.filter) > 0 {
+					m.modalSelector.filter = m.modalSelector.filter[:len(m.modalSelector.filter)-1]
+					m.modalSelector.cursor = 0
+					m.modalSelector.scrollOffset = 0
+				}
+
+			case tea.KeyRunes:
+				m.modalSelector.filter += string(msg.Runes)
+				m.modalSelector.cursor = 0
+				m.modalSelector.scrollOffset = 0
 			}
 		}
 		return m, nil
@@ -488,30 +463,32 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.cursor > 0 {
 				m.cursor--
 			}
-			// Auto-collapse "Others" when cursor moves back into pinned items
-			if m.showOthers && m.cursor < len(mainMenuItems) {
-				m.showOthers = false
-				m.buildItems()
-			}

 		case "down", "j":
 			if m.cursor < len(m.items)-1 {
 				m.cursor++
 			}
-			// Auto-expand "Others..." when cursor lands on it
-			if m.cursor < len(m.items) && m.items[m.cursor].isOthers && !m.showOthers {
-				m.showOthers = true
-				m.buildItems()
-				// cursor now points at the first "other" integration
-			}

 		case "enter", " ":
 			item := m.items[m.cursor]

+			// Handle "Others..." toggle
+			if item.isOthers {
+				m.showOthers = !m.showOthers
+				m.buildItems()
+				// Keep cursor on the Others/Hide item
+				if m.cursor >= len(m.items) {
+					m.cursor = len(m.items) - 1
+				}
+				return m, nil
+			}
+
+			// Don't allow selecting uninstalled integrations
 			if item.integration != "" && !config.IsIntegrationInstalled(item.integration) {
 				return m, nil
 			}

+			// Check if a cloud model is configured and needs sign-in
 			var configuredModel string
 			if item.isRunModel {
 				configuredModel = config.LastModel()
@@ -522,36 +499,19 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 				return m, cmd
 			}

-			if configuredModel != "" && isCloudModel(configuredModel) && cloudModelDisabled(configuredModel) {
-				if item.integration != "" && config.IsEditorIntegration(item.integration) {
-					m.openMultiModelModal(item.integration)
-				} else {
-					m.openModelModal(configuredModel)
-				}
-				return m, nil
-			}
-
 			m.selected = true
 			m.quitting = true
 			return m, tea.Quit

 		case "right", "l":
+			// Allow model change for integrations and run model
 			item := m.items[m.cursor]
 			if item.integration != "" || item.isRunModel {
+				// Don't allow for uninstalled integrations
 				if item.integration != "" && !config.IsIntegrationInstalled(item.integration) {
 					return m, nil
 				}
-				if item.integration != "" && config.IsEditorIntegration(item.integration) {
-					m.openMultiModelModal(item.integration)
-				} else {
-					var currentModel string
-					if item.isRunModel {
-						currentModel = config.LastModel()
-					} else if item.integration != "" {
-						currentModel = config.IntegrationModel(item.integration)
-					}
-					m.openModelModal(currentModel)
-				}
+				m.openModelModal()
 			}
 		}
 	}
@@ -564,23 +524,21 @@ func (m model) View() string {
 		return ""
 	}

+	// Render sign-in dialog if showing
 	if m.showingSignIn {
 		return m.renderSignInDialog()
 	}

-	if m.showingMultiModal {
-		return m.multiModalSelector.View()
-	}
-
+	// Render modal overlay if showing - replaces main view
 	if m.showingModal {
 		return m.renderModal()
 	}

-	s := selectorTitleStyle.Render("Ollama "+versionStyle.Render(version.Version)) + "\n\n"
+	s := titleStyle.Render("  Ollama "+versionStyle.Render("v"+version.Version)) + "\n\n"

 	for i, item := range m.items {
-		cursor := ""
-		style := menuItemStyle
+		cursor := "  "
+		style := itemStyle
 		isInstalled := true

 		if item.integration != "" {
@@ -590,7 +548,7 @@ func (m model) View() string {
 		if m.cursor == i {
 			cursor = "▸ "
 			if isInstalled {
-				style = menuSelectedItemStyle
+				style = selectedStyle
 			} else {
 				style = greyedSelectedStyle
 			}
@@ -599,62 +557,119 @@ func (m model) View() string {
 		}

 		title := item.title
-		var modelSuffix string
 		if item.integration != "" {
 			if !isInstalled {
 				title += " " + notInstalledStyle.Render("(not installed)")
-			} else if m.cursor == i {
-				if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
-					modelSuffix = " " + modelStyle.Render("("+mdl+")")
-				}
+			} else if mdl := config.IntegrationModel(item.integration); mdl != "" && m.modelExists(mdl) {
+				title += " " + modelStyle.Render("("+mdl+")")
 			}
-		} else if item.isRunModel && m.cursor == i {
+		} else if item.isRunModel {
 			if mdl := config.LastModel(); mdl != "" && m.modelExists(mdl) {
-				modelSuffix = " " + modelStyle.Render("("+mdl+")")
+				title += " " + modelStyle.Render("("+mdl+")")
 			}
 		}

-		s += style.Render(cursor+title) + modelSuffix + "\n"
-
-		desc := item.description
-		if !isInstalled && item.integration != "" && m.cursor == i {
-			if hint := config.IntegrationInstallHint(item.integration); hint != "" {
-				desc = hint
-			} else {
-				desc = "not installed"
-			}
-		}
-		s += menuDescStyle.Render(desc) + "\n\n"
+		s += style.Render(cursor+title) + "\n"
+		s += descStyle.Render(item.description) + "\n\n"
 	}

-	if m.statusMsg != "" {
-		s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.AdaptiveColor{Light: "124", Dark: "210"}).Render(m.statusMsg) + "\n"
-	}
+	s += "\n" + lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render("↑/↓ navigate • enter select • → change model • esc quit")

-	s += "\n" + selectorHelpStyle.Render("↑/↓ navigate • enter launch • → change model • esc quit")
-
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
-	}
 	return s
 }

+// renderModal renders the model picker modal.
 func (m model) renderModal() string {
 	modalStyle := lipgloss.NewStyle().
-		PaddingBottom(1).
-		PaddingRight(2)
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("245")).
+		Padding(1, 2).
+		MarginLeft(2)

-	s := modalStyle.Render(m.modalSelector.renderContent())
-	if m.width > 0 {
-		return lipgloss.NewStyle().MaxWidth(m.width).Render(s)
+	var content strings.Builder
+
+	// Title with filter
+	content.WriteString(selectorTitleStyle.Render(m.modalSelector.title))
+	content.WriteString(" ")
+	if m.modalSelector.filter == "" {
+		content.WriteString(selectorFilterStyle.Render("Type to filter..."))
+	} else {
+		content.WriteString(selectorInputStyle.Render(m.modalSelector.filter))
 	}
-	return s
+	content.WriteString("\n\n")
+
+	filtered := m.modalSelector.filteredItems()
+
+	if len(filtered) == 0 {
+		content.WriteString(selectorItemStyle.Render(selectorDescStyle.Render("(no matches)")))
+		content.WriteString("\n")
+	} else {
+		displayCount := min(len(filtered), maxSelectorItems)
+
+		for i := range displayCount {
+			idx := m.modalSelector.scrollOffset + i
+			if idx >= len(filtered) {
+				break
+			}
+			item := filtered[idx]
+
+			if idx == m.modalSelector.cursor {
+				content.WriteString(selectorSelectedItemStyle.Render("▸ " + item.Name))
+			} else {
+				content.WriteString(selectorItemStyle.Render(item.Name))
+			}
+
+			if item.Description != "" {
+				content.WriteString(" ")
+				content.WriteString(selectorDescStyle.Render("- " + item.Description))
+			}
+			content.WriteString("\n")
+		}
+
+		if remaining := len(filtered) - m.modalSelector.scrollOffset - displayCount; remaining > 0 {
+			content.WriteString(selectorMoreStyle.Render(fmt.Sprintf("... and %d more", remaining)))
+			content.WriteString("\n")
+		}
+	}
+
+	content.WriteString("\n")
+	content.WriteString(selectorHelpStyle.Render("↑/↓ navigate • enter select • esc cancel"))
+
+	return modalStyle.Render(content.String())
 }

+// renderSignInDialog renders the sign-in dialog.
 func (m model) renderSignInDialog() string {
-	return renderSignIn(m.signInModel, m.signInURL, m.signInSpinner, m.width)
+	dialogStyle := lipgloss.NewStyle().
+		Border(lipgloss.RoundedBorder()).
+		BorderForeground(lipgloss.Color("245")).
+		Padding(1, 2).
+		MarginLeft(2)
+
+	spinnerFrames := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
+	spinner := spinnerFrames[m.signInSpinner%len(spinnerFrames)]
+
+	var content strings.Builder
+
+	content.WriteString(selectorTitleStyle.Render("Sign in required"))
+	content.WriteString("\n\n")
+
+	content.WriteString(fmt.Sprintf("To use %s, please sign in.\n\n", selectedStyle.Render(m.signInModel)))
+
+	content.WriteString("Navigate to:\n")
+	content.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("117")).Render("  " + m.signInURL))
+	content.WriteString("\n\n")
+
+	content.WriteString(lipgloss.NewStyle().Foreground(lipgloss.Color("241")).Render(
+		fmt.Sprintf("%s Waiting for sign in to complete...", spinner)))
+	content.WriteString("\n\n")
+
+	content.WriteString(selectorHelpStyle.Render("esc cancel"))
+
+	return dialogStyle.Render(content.String())
 }

+// Selection represents what the user selected
 type Selection int

 const (
@@ -665,13 +680,14 @@ const (
 	SelectionChangeIntegration // Generic change model for integration
 )

+// Result contains the selection and any associated data
 type Result struct {
 	Selection   Selection
-	Integration string   // integration name if applicable
-	Model       string   // model name if selected from single-select modal
-	Models      []string // models selected from multi-select modal (Editor integrations)
+	Integration string // integration name if applicable
+	Model       string // model name if selected from modal
 }

+// Run starts the TUI and returns the user's selection
 func Run() (Result, error) {
 	m := initialModel()
 	p := tea.NewProgram(m)
@@ -686,12 +702,14 @@ func Run() (Result, error) {
 		return Result{Selection: SelectionNone}, fm.err
 	}

+	// User quit without selecting
 	if !fm.selected && !fm.changeModel {
 		return Result{Selection: SelectionNone}, nil
 	}

 	item := fm.items[fm.cursor]

+	// Handle model change request
 	if fm.changeModel {
 		if item.isRunModel {
 			return Result{
@@ -703,10 +721,10 @@ func Run() (Result, error) {
 			Selection:   SelectionChangeIntegration,
 			Integration: item.integration,
 			Model:       fm.modalSelector.selected,
-			Models:      fm.changeModels,
 		}, nil
 	}

+	// Handle selection
 	if item.isRunModel {
 		return Result{Selection: SelectionRunModel}, nil
 	}
--- a/docs/cloud.mdx
+++ b/docs/cloud.mdx
@@ -226,7 +226,3 @@ curl https://ollama.com/api/chat \

  </Tab>
 </Tabs>
-
-## Local only
-
-Ollama can run in local-only mode by [disabling Ollama's cloud](./faq#how-do-i-disable-ollama-cloud) features.
--- a/docs/faq.mdx
+++ b/docs/faq.mdx
@@ -160,26 +160,6 @@ docker run -d -e HTTPS_PROXY=https://my.proxy.example.com -p 11434:11434 ollama-

 Ollama runs locally. We don't see your prompts or data when you run locally. When using cloud-hosted models, we process your prompts and responses to provide the service but do not store or log that content and never train on it. We collect basic account info and limited usage metadata to provide the service that does not include prompt or response content. We don't sell your data. You can delete your account anytime.

-## How do I disable Ollama's cloud features?
-
-Ollama can run in local only mode by disabling Ollama's cloud features. By turning off Ollama's cloud features, you will lose the ability to use Ollama's cloud models and web search. 
-
-Set `disable_ollama_cloud` in `~/.ollama/server.json`:
-
-```json
-{
-  "disable_ollama_cloud": true
-}
-```
-
-You can also set the environment variable:
-
-```shell
-OLLAMA_NO_CLOUD=1
-```
-
-Restart Ollama after changing configuration. Once disabled, Ollama's logs will show `Ollama cloud disabled: true`. 
-
 ## How can I expose Ollama on my network?

 Ollama binds 127.0.0.1 port 11434 by default. Change the bind address with the `OLLAMA_HOST` environment variable.
--- a/docs/openapi.yaml
+++ b/docs/openapi.yaml
@@ -596,15 +596,6 @@ components:
        name:
          type: string
          description: Model name
-        model:
-          type: string
-          description: Model name
-        remote_model:
-          type: string
-          description: Name of the upstream model, if the model is remote
-        remote_host:
-          type: string
-          description: URL of the upstream Ollama host, if the model is remote
        modified_at:
          type: string
          description: Last modified timestamp in ISO 8601 format
@@ -645,9 +636,6 @@ components:
    Ps:
      type: object
      properties:
-        name:
-          type: string
-          description: Name of the running model
        model:
          type: string
          description: Name of the running model
@@ -1149,7 +1137,6 @@ paths:
              example:
                models:
                  - name: "gemma3"
-                    model: "gemma3"
                    modified_at: "2025-10-03T23:34:03.409490317-07:00"
                    size: 3338801804
                    digest: "a2af6cc3eb7fa8be8504abaf9b04e88f17a119ec3f04a3addf55f92841195f5a"
@@ -1181,8 +1168,7 @@ paths:
                $ref: "#/components/schemas/PsResponse"
              example:
                models:
-                  - name: "gemma3"
-                    model: "gemma3"
+                  - model: "gemma3"
                    size: 6591830464
                    digest: "a2af6cc3eb7fa8be8504abaf9b04e88f17a119ec3f04a3addf55f92841195f5a"
                    details:
--- a/docs/quickstart.mdx
+++ b/docs/quickstart.mdx
@@ -2,7 +2,7 @@
 title: Quickstart
 ---

-Ollama is available on macOS, Windows, and Linux.
+This quickstart will walk your through running your first model with Ollama. To get started, download Ollama on macOS, Windows or Linux.

 <a
  href="https://ollama.com/download"
@@ -12,48 +12,131 @@ Ollama is available on macOS, Windows, and Linux.
  Download Ollama
 </a>

-## Get Started
+## Run a model

-Run `ollama` in your terminal to open the interactive menu:
+<Tabs>
+  <Tab title="CLI">
+    Open a terminal and run the command:

+    ```sh
+    ollama run gemma3
+    ```
+
+  </Tab>
+  <Tab title="cURL">
+    ```sh
+    ollama pull gemma3
+    ```
+
+    Lastly, chat with the model:
+
+    ```shell
+    curl http://localhost:11434/api/chat -d '{
+      "model": "gemma3",
+      "messages": [{
+        "role": "user",
+        "content": "Hello there!"
+      }],
+      "stream": false
+    }'
+    ```
+
+  </Tab>
+  <Tab title="Python">
+    Start by downloading a model:
+
+    ```sh
+    ollama pull gemma3
+    ```
+
+    Then install Ollama's Python library:
+
+    ```sh
+    pip install ollama
+    ```
+
+    Lastly, chat with the model:
+
+    ```python
+    from ollama import chat
+    from ollama import ChatResponse
+
+    response: ChatResponse = chat(model='gemma3', messages=[
+      {
+        'role': 'user',
+        'content': 'Why is the sky blue?',
+      },
+    ])
+    print(response['message']['content'])
+    # or access fields directly from the response object
+    print(response.message.content)
+    ```
+
+  </Tab>
+  <Tab title="JavaScript">
+    Start by downloading a model:
+
+    ```
+    ollama pull gemma3
+    ```
+
+    Then install the Ollama JavaScript library:
+    ```
+    npm i ollama
+    ```
+
+    Lastly, chat with the model:
+
+    ```shell
+    import ollama from 'ollama'
+
+    const response = await ollama.chat({
+      model: 'gemma3',
+      messages: [{ role: 'user', content: 'Why is the sky blue?' }],
+    })
+    console.log(response.message.content)
+    ```
+
+  </Tab>
+</Tabs>
+
+See a full list of available models [here](https://ollama.com/models).
+
+## Coding 
+
+For coding use cases, we recommend using the `glm-4.7-flash` model. 
+
+Note: this model requires 23 GB of VRAM with 64000 tokens context length.
 ```sh
-ollama
+ollama pull glm-4.7-flash 
 ```

-Navigate with `↑/↓`, press `enter` to launch, `→` to change model, and `esc` to quit.
-
-The menu provides quick access to:
- **Run a model** - Start an interactive chat
- **Launch tools** - Claude Code, Codex, OpenClaw, and more
- **Additional integrations** - Available under "More..."
-
-## Coding
-
-Launch coding tools with Ollama models:
-
+Alternatively, you can use a more powerful cloud model (with full context length):
 ```sh
-ollama launch claude
+ollama pull glm-4.7:cloud
 ```

-```sh
-ollama launch codex
-```
+Use `ollama launch` to quickly set up a coding tool with Ollama models:

 ```sh
-ollama launch opencode
+ollama launch
 ```

-See [integrations](/integrations) for all supported tools.
+### Supported integrations

-## API
+- [OpenCode](/integrations/opencode) - Open-source coding assistant
+- [Claude Code](/integrations/claude-code) - Anthropic's agentic coding tool
+- [Codex](/integrations/codex) - OpenAI's coding assistant
+- [Droid](/integrations/droid) - Factory's AI coding agent

-Use the [API](/api) to integrate Ollama into your applications:
+### Launch with a specific model

 ```sh
-curl http://localhost:11434/api/chat -d '{
-  "model": "gemma3",
-  "messages": [{ "role": "user", "content": "Hello!" }]
-}'
+ollama launch claude --model glm-4.7-flash
 ```

-See the [API documentation](/api) for Python, JavaScript, and other integrations.
+### Configure without launching
+
+```sh
+ollama launch claude --config
+```
--- a/envconfig/config.go
+++ b/envconfig/config.go
@@ -1,8 +1,6 @@
 package envconfig

 import (
-	"encoding/json"
-	"errors"
 	"fmt"
 	"log/slog"
 	"math"
@@ -13,7 +11,6 @@ import (
 	"runtime"
 	"strconv"
 	"strings"
-	"sync"
 	"time"
 )

@@ -209,8 +206,6 @@ var (
 	UseAuth = Bool("OLLAMA_AUTH")
 	// Enable Vulkan backend
 	EnableVulkan = Bool("OLLAMA_VULKAN")
-	// NoCloudEnv checks the OLLAMA_NO_CLOUD environment variable.
-	NoCloudEnv = Bool("OLLAMA_NO_CLOUD")
 )

 func String(s string) func() string {
@@ -221,7 +216,6 @@ func String(s string) func() string {

 var (
 	LLMLibrary = String("OLLAMA_LLM_LIBRARY")
-	Editor     = String("OLLAMA_EDITOR")

 	CudaVisibleDevices    = String("CUDA_VISIBLE_DEVICES")
 	HipVisibleDevices     = String("HIP_VISIBLE_DEVICES")
@@ -290,7 +284,6 @@ func AsMap() map[string]EnvVar {
 		"OLLAMA_MAX_LOADED_MODELS": {"OLLAMA_MAX_LOADED_MODELS", MaxRunners(), "Maximum number of loaded models per GPU"},
 		"OLLAMA_MAX_QUEUE":         {"OLLAMA_MAX_QUEUE", MaxQueue(), "Maximum number of queued requests"},
 		"OLLAMA_MODELS":            {"OLLAMA_MODELS", Models(), "The path to the models directory"},
-		"OLLAMA_NO_CLOUD":          {"OLLAMA_NO_CLOUD", NoCloud(), "Disable Ollama cloud features (remote inference and web search)"},
 		"OLLAMA_NOHISTORY":         {"OLLAMA_NOHISTORY", NoHistory(), "Do not preserve readline history"},
 		"OLLAMA_NOPRUNE":           {"OLLAMA_NOPRUNE", NoPrune(), "Do not prune model blobs on startup"},
 		"OLLAMA_NUM_PARALLEL":      {"OLLAMA_NUM_PARALLEL", NumParallel(), "Maximum number of parallel requests"},
@@ -298,7 +291,6 @@ func AsMap() map[string]EnvVar {
 		"OLLAMA_SCHED_SPREAD":      {"OLLAMA_SCHED_SPREAD", SchedSpread(), "Always schedule model across all GPUs"},
 		"OLLAMA_MULTIUSER_CACHE":   {"OLLAMA_MULTIUSER_CACHE", MultiUserCache(), "Optimize prompt caching for multi-user scenarios"},
 		"OLLAMA_CONTEXT_LENGTH":    {"OLLAMA_CONTEXT_LENGTH", ContextLength(), "Context length to use unless otherwise specified (default: 4k/32k/256k based on VRAM)"},
-		"OLLAMA_EDITOR":            {"OLLAMA_EDITOR", Editor(), "Path to editor for interactive prompt editing (Ctrl+G)"},
 		"OLLAMA_NEW_ENGINE":        {"OLLAMA_NEW_ENGINE", NewEngine(), "Enable the new Ollama engine"},
 		"OLLAMA_REMOTES":           {"OLLAMA_REMOTES", Remotes(), "Allowed hosts for remote models (default \"ollama.com\")"},

@@ -340,91 +332,3 @@ func Values() map[string]string {
 func Var(key string) string {
 	return strings.Trim(strings.TrimSpace(os.Getenv(key)), "\"'")
 }
-
-// serverConfigData holds the parsed fields from ~/.ollama/server.json.
-type serverConfigData struct {
-	DisableOllamaCloud bool `json:"disable_ollama_cloud,omitempty"`
-}
-
-var (
-	serverCfgMu     sync.RWMutex
-	serverCfgLoaded bool
-	serverCfg       serverConfigData
-)
-
-func loadServerConfig() {
-	serverCfgMu.RLock()
-	if serverCfgLoaded {
-		serverCfgMu.RUnlock()
-		return
-	}
-	serverCfgMu.RUnlock()
-
-	cfg := serverConfigData{}
-	home, err := os.UserHomeDir()
-	if err == nil {
-		path := filepath.Join(home, ".ollama", "server.json")
-		data, err := os.ReadFile(path)
-		if err != nil {
-			if !errors.Is(err, os.ErrNotExist) {
-				slog.Debug("envconfig: could not read server config", "error", err)
-			}
-		} else if err := json.Unmarshal(data, &cfg); err != nil {
-			slog.Debug("envconfig: could not parse server config", "error", err)
-		}
-	}
-
-	serverCfgMu.Lock()
-	defer serverCfgMu.Unlock()
-	if serverCfgLoaded {
-		return
-	}
-	serverCfg = cfg
-	serverCfgLoaded = true
-}
-
-func cachedServerConfig() serverConfigData {
-	serverCfgMu.RLock()
-	defer serverCfgMu.RUnlock()
-	return serverCfg
-}
-
-// ReloadServerConfig refreshes the cached ~/.ollama/server.json settings.
-func ReloadServerConfig() {
-	serverCfgMu.Lock()
-	serverCfgLoaded = false
-	serverCfg = serverConfigData{}
-	serverCfgMu.Unlock()
-
-	loadServerConfig()
-}
-
-// NoCloud returns true if Ollama cloud features are disabled,
-// checking both the OLLAMA_NO_CLOUD environment variable and
-// the disable_ollama_cloud field in ~/.ollama/server.json.
-func NoCloud() bool {
-	if NoCloudEnv() {
-		return true
-	}
-	loadServerConfig()
-	return cachedServerConfig().DisableOllamaCloud
-}
-
-// NoCloudSource returns the source of the cloud-disabled decision.
-// Returns "none", "env", "config", or "both".
-func NoCloudSource() string {
-	envDisabled := NoCloudEnv()
-	loadServerConfig()
-	configDisabled := cachedServerConfig().DisableOllamaCloud
-
-	switch {
-	case envDisabled && configDisabled:
-		return "both"
-	case envDisabled:
-		return "env"
-	case configDisabled:
-		return "config"
-	default:
-		return "none"
-	}
-}
--- a/envconfig/config_test.go
+++ b/envconfig/config_test.go
@@ -3,8 +3,6 @@ package envconfig
 import (
 	"log/slog"
 	"math"
-	"os"
-	"path/filepath"
 	"testing"
 	"time"

@@ -328,81 +326,3 @@ func TestLogLevel(t *testing.T) {
 		})
 	}
 }
-
-func TestNoCloud(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		wantDisabled  bool
-		wantSource    string
-	}{
-		{
-			name:         "neither env nor config",
-			wantDisabled: false,
-			wantSource:   "none",
-		},
-		{
-			name:         "env only",
-			envValue:     "1",
-			wantDisabled: true,
-			wantSource:   "env",
-		},
-		{
-			name:          "config only",
-			configContent: `{"disable_ollama_cloud": true}`,
-			wantDisabled:  true,
-			wantSource:    "config",
-		},
-		{
-			name:          "both env and config",
-			envValue:      "1",
-			configContent: `{"disable_ollama_cloud": true}`,
-			wantDisabled:  true,
-			wantSource:    "both",
-		},
-		{
-			name:          "config false",
-			configContent: `{"disable_ollama_cloud": false}`,
-			wantDisabled:  false,
-			wantSource:    "none",
-		},
-		{
-			name:          "invalid config ignored",
-			configContent: `{invalid json`,
-			wantDisabled:  false,
-			wantSource:    "none",
-		},
-		{
-			name:         "no config file",
-			wantDisabled: false,
-			wantSource:   "none",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			home := t.TempDir()
-			if tt.configContent != "" {
-				configDir := filepath.Join(home, ".ollama")
-				if err := os.MkdirAll(configDir, 0o755); err != nil {
-					t.Fatal(err)
-				}
-				if err := os.WriteFile(filepath.Join(configDir, "server.json"), []byte(tt.configContent), 0o644); err != nil {
-					t.Fatal(err)
-				}
-			}
-
-			setTestHome(t, home)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			if got := NoCloud(); got != tt.wantDisabled {
-				t.Errorf("NoCloud() = %v, want %v", got, tt.wantDisabled)
-			}
-
-			if got := NoCloudSource(); got != tt.wantSource {
-				t.Errorf("NoCloudSource() = %q, want %q", got, tt.wantSource)
-			}
-		})
-	}
-}
--- a/envconfig/test_home_test.go
+++ b/envconfig/test_home_test.go
@@ -1,10 +0,0 @@
-package envconfig
-
-import "testing"
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	ReloadServerConfig()
-}
--- a/internal/cloud/policy.go
+++ b/internal/cloud/policy.go
@@ -1,25 +0,0 @@
-package cloud
-
-import (
-	"github.com/ollama/ollama/envconfig"
-)
-
-const DisabledMessagePrefix = "ollama cloud is disabled"
-
-// Status returns whether cloud is disabled and the source of the decision.
-// Source is one of: "none", "env", "config", "both".
-func Status() (disabled bool, source string) {
-	return envconfig.NoCloud(), envconfig.NoCloudSource()
-}
-
-func Disabled() bool {
-	return envconfig.NoCloud()
-}
-
-func DisabledError(operation string) string {
-	if operation == "" {
-		return DisabledMessagePrefix
-	}
-
-	return DisabledMessagePrefix + ": " + operation
-}
--- a/internal/cloud/policy_test.go
+++ b/internal/cloud/policy_test.go
@@ -1,85 +0,0 @@
-package cloud
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestStatus(t *testing.T) {
-	tests := []struct {
-		name          string
-		envValue      string
-		configContent string
-		disabled      bool
-		source        string
-	}{
-		{
-			name:     "none",
-			disabled: false,
-			source:   "none",
-		},
-		{
-			name:     "env only",
-			envValue: "1",
-			disabled: true,
-			source:   "env",
-		},
-		{
-			name:          "config only",
-			configContent: `{"disable_ollama_cloud": true}`,
-			disabled:      true,
-			source:        "config",
-		},
-		{
-			name:          "both",
-			envValue:      "1",
-			configContent: `{"disable_ollama_cloud": true}`,
-			disabled:      true,
-			source:        "both",
-		},
-		{
-			name:          "invalid config ignored",
-			configContent: `{invalid json`,
-			disabled:      false,
-			source:        "none",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			home := t.TempDir()
-			if tt.configContent != "" {
-				configPath := filepath.Join(home, ".ollama", "server.json")
-				if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-					t.Fatal(err)
-				}
-				if err := os.WriteFile(configPath, []byte(tt.configContent), 0o644); err != nil {
-					t.Fatal(err)
-				}
-			}
-
-			setTestHome(t, home)
-			t.Setenv("OLLAMA_NO_CLOUD", tt.envValue)
-
-			disabled, source := Status()
-			if disabled != tt.disabled {
-				t.Fatalf("disabled: expected %v, got %v", tt.disabled, disabled)
-			}
-			if source != tt.source {
-				t.Fatalf("source: expected %q, got %q", tt.source, source)
-			}
-		})
-	}
-}
-
-func TestDisabledError(t *testing.T) {
-	if got := DisabledError(""); got != DisabledMessagePrefix {
-		t.Fatalf("expected %q, got %q", DisabledMessagePrefix, got)
-	}
-
-	want := DisabledMessagePrefix + ": remote inference is unavailable"
-	if got := DisabledError("remote inference is unavailable"); got != want {
-		t.Fatalf("expected %q, got %q", want, got)
-	}
-}
--- a/internal/cloud/test_home_test.go
+++ b/internal/cloud/test_home_test.go
@@ -1,14 +0,0 @@
-package cloud
-
-import (
-	"testing"
-
-	"github.com/ollama/ollama/envconfig"
-)
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	envconfig.ReloadServerConfig()
-}
--- a/readline/errors.go
+++ b/readline/errors.go
@@ -5,7 +5,6 @@ import (
 )

 var ErrInterrupt = errors.New("Interrupt")
-var ErrEditPrompt = errors.New("EditPrompt")

 type InterruptError struct {
 	Line []rune
--- a/readline/readline.go
+++ b/readline/readline.go
@@ -41,7 +41,6 @@ type Instance struct {
 	Terminal    *Terminal
 	History     *History
 	Pasting     bool
-	Prefill     string
 	pastedLines []string
 }

@@ -90,27 +89,6 @@ func (i *Instance) Readline() (string, error) {

 	buf, _ := NewBuffer(i.Prompt)

-	// Prefill the buffer with any text that we received from an external editor
-	if i.Prefill != "" {
-		lines := strings.Split(i.Prefill, "\n")
-		i.Prefill = ""
-		for idx, l := range lines {
-			for _, r := range l {
-				buf.Add(r)
-			}
-			if idx < len(lines)-1 {
-				i.pastedLines = append(i.pastedLines, buf.String())
-				buf.Buf.Clear()
-				buf.Pos = 0
-				buf.DisplayPos = 0
-				buf.LineHasSpace.Clear()
-				fmt.Println()
-				fmt.Print(i.Prompt.AltPrompt)
-				i.Prompt.UseAlt = true
-			}
-		}
-	}
-
 	var esc bool
 	var escex bool
 	var metaDel bool
@@ -273,29 +251,6 @@ func (i *Instance) Readline() (string, error) {
 			buf.ClearScreen()
 		case CharCtrlW:
 			buf.DeleteWord()
-		case CharBell:
-			output := buf.String()
-			numPastedLines := len(i.pastedLines)
-			if numPastedLines > 0 {
-				output = strings.Join(i.pastedLines, "\n") + "\n" + output
-				i.pastedLines = nil
-			}
-
-			// Move cursor to the last display line of the current buffer
-			currLine := buf.DisplayPos / buf.LineWidth
-			lastLine := buf.DisplaySize() / buf.LineWidth
-			if lastLine > currLine {
-				fmt.Print(CursorDownN(lastLine - currLine))
-			}
-
-			// Clear all lines from bottom to top: buffer wrapped lines + pasted lines
-			for range lastLine + numPastedLines {
-				fmt.Print(CursorBOL + ClearToEOL + CursorUp)
-			}
-			fmt.Print(CursorBOL + ClearToEOL)
-
-			i.Prompt.UseAlt = false
-			return output, ErrEditPrompt
 		case CharCtrlZ:
 			fd := os.Stdin.Fd()
 			return handleCharCtrlZ(fd, i.Terminal.termios)
--- a/scripts/install.ps1
+++ b/scripts/install.ps1
@@ -136,64 +136,12 @@ function Invoke-Download {

    Write-Status "  Downloading: $Url"
    try {
-        $request = [System.Net.HttpWebRequest]::Create($Url)
-        $request.AllowAutoRedirect = $true
-        $response = $request.GetResponse()
-        $totalBytes = $response.ContentLength
-        $stream = $response.GetResponseStream()
-        $fileStream = [System.IO.FileStream]::new($OutFile, [System.IO.FileMode]::Create)
-        $buffer = [byte[]]::new(65536)
-        $totalRead = 0
-        $lastUpdate = [DateTime]::MinValue
-        $barWidth = 40
-
-        try {
-            while (($read = $stream.Read($buffer, 0, $buffer.Length)) -gt 0) {
-                $fileStream.Write($buffer, 0, $read)
-                $totalRead += $read
-
-                $now = [DateTime]::UtcNow
-                if (($now - $lastUpdate).TotalMilliseconds -ge 250) {
-                    if ($totalBytes -gt 0) {
-                        $pct = [math]::Min(100.0, ($totalRead / $totalBytes) * 100)
-                        $filled = [math]::Floor($barWidth * $pct / 100)
-                        $empty = $barWidth - $filled
-                        $bar = ('#' * $filled) + (' ' * $empty)
-                        $pctFmt = $pct.ToString("0.0")
-                        Write-Host -NoNewline "`r$bar ${pctFmt}%"
-                    } else {
-                        $sizeMB = [math]::Round($totalRead / 1MB, 1)
-                        Write-Host -NoNewline "`r${sizeMB} MB downloaded..."
-                    }
-                    $lastUpdate = $now
-                }
-            }
-
-            # Final progress update
-            if ($totalBytes -gt 0) {
-                $bar = '#' * $barWidth
-                Write-Host "`r$bar 100.0%"
-            } else {
-                $sizeMB = [math]::Round($totalRead / 1MB, 1)
-                Write-Host "`r${sizeMB} MB downloaded.          "
-            }
-        } finally {
-            $fileStream.Close()
-            $stream.Close()
-            $response.Close()
-        }
+        Invoke-WebRequest -Uri $Url -OutFile $OutFile -UseBasicParsing
+        $size = (Get-Item $OutFile).Length
+        Write-Status "  Downloaded: $([math]::Round($size / 1MB, 1)) MB"
    } catch {
-        if ($_.Exception -is [System.Net.WebException]) {
-            $webEx = [System.Net.WebException]$_.Exception
-            if ($webEx.Response -and ([System.Net.HttpWebResponse]$webEx.Response).StatusCode -eq [System.Net.HttpStatusCode]::NotFound) {
-                throw "Download failed: not found at $Url"
-            }
-        }
-        if ($_.Exception.InnerException -is [System.Net.WebException]) {
-            $webEx = [System.Net.WebException]$_.Exception.InnerException
-            if ($webEx.Response -and ([System.Net.HttpWebResponse]$webEx.Response).StatusCode -eq [System.Net.HttpStatusCode]::NotFound) {
-                throw "Download failed: not found at $Url"
-            }
+        if ($_.Exception.Response.StatusCode -eq 404) {
+            throw "Download failed: not found at $Url"
        }
        throw "Download failed for ${Url}: $($_.Exception.Message)"
    }
@@ -208,7 +156,7 @@ function Invoke-Uninstall {

    $regKey = Find-InnoSetupInstall
    if (-not $regKey) {
-        Write-Host ">>> Ollama is not installed."
+        Write-Host "Ollama is not installed."
        return
    }

@@ -227,7 +175,7 @@ function Invoke-Uninstall {
        return
    }

-    Write-Host ">>> Launching uninstaller..."
+    Write-Host "Launching uninstaller..."
    # Run with GUI so user can choose whether to keep models
    Start-Process -FilePath $uninstallExe -Wait

@@ -235,7 +183,7 @@ function Invoke-Uninstall {
    if (Find-InnoSetupInstall) {
        Write-Warning "Uninstall may not have completed"
    } else {
-        Write-Host ">>> Ollama has been uninstalled."
+        Write-Host "Ollama has been uninstalled."
    }
 }

@@ -254,7 +202,7 @@ function Invoke-Install {
    # Download installer
    Write-Step "Downloading Ollama"
    if (-not $DebugInstall) {
-        Write-Host ">>> Downloading Ollama for Windows..."
+        Write-Host "Downloading Ollama..."
    }

    $tempInstaller = Join-Path $env:TEMP "OllamaSetup.exe"
@@ -277,7 +225,7 @@ function Invoke-Install {
    # Run installer
    Write-Step "Installing Ollama"
    if (-not $DebugInstall) {
-        Write-Host ">>> Installing Ollama..."
+        Write-Host "Installing..."
    }

    # Create upgrade marker so the app starts hidden
@@ -309,7 +257,7 @@ function Invoke-Install {
    Write-Step "Updating session PATH"
    Update-SessionPath

-    Write-Host ">>> Install complete. Run 'ollama' from the command line."
+    Write-Host "Install complete. You can now run 'ollama'."
 }

 # --------------------------------------------------------------------------
--- a/scripts/install.sh
+++ b/scripts/install.sh
@@ -72,12 +72,10 @@ if [ "$OS" = "Darwin" ]; then
    unzip -q "$TEMP_DIR/Ollama-darwin.zip" -d "$TEMP_DIR"
    mv "$TEMP_DIR/Ollama.app" "/Applications/"

-    if [ ! -L "/usr/local/bin/ollama" ] || [ "$(readlink "/usr/local/bin/ollama")" != "/Applications/Ollama.app/Contents/Resources/ollama" ]; then
-        status "Adding 'ollama' command to PATH (may require password)..."
-        mkdir -p "/usr/local/bin" 2>/dev/null || sudo mkdir -p "/usr/local/bin"
-        ln -sf "/Applications/Ollama.app/Contents/Resources/ollama" "/usr/local/bin/ollama" 2>/dev/null || \
-            sudo ln -sf "/Applications/Ollama.app/Contents/Resources/ollama" "/usr/local/bin/ollama"
-    fi
+    status "Adding 'ollama' command to PATH (may require password)..."
+    mkdir -p "/usr/local/bin" 2>/dev/null || sudo mkdir -p "/usr/local/bin"
+    ln -sf "/Applications/Ollama.app/Contents/Resources/ollama" "/usr/local/bin/ollama" 2>/dev/null || \
+        sudo ln -sf "/Applications/Ollama.app/Contents/Resources/ollama" "/usr/local/bin/ollama"

    if [ -z "${OLLAMA_NO_START:-}" ]; then
        status "Starting Ollama..."
--- a/server/aliases.go
+++ b/server/aliases.go
@@ -115,15 +115,6 @@ func (s *store) saveLocked() error {
 		return err
 	}

-	// Read existing file into a generic map to preserve unknown fields
-	// (e.g. disable_ollama_cloud) that aliasStore doesn't own.
-	existing := make(map[string]json.RawMessage)
-	if data, err := os.ReadFile(s.path); err == nil {
-		if err := json.Unmarshal(data, &existing); err != nil {
-			slog.Debug("failed to parse existing server config; preserving unknown fields skipped", "path", s.path, "error", err)
-		}
-	}
-
 	// Combine exact and prefix entries
 	entries := make([]aliasEntry, 0, len(s.entries)+len(s.prefixEntries))
 	for _, entry := range s.entries {
@@ -135,17 +126,10 @@ func (s *store) saveLocked() error {
 		return strings.Compare(entries[i].Alias, entries[j].Alias) < 0
 	})

-	// Overwrite only the keys we own
-	versionJSON, err := json.Marshal(serverConfigVersion)
-	if err != nil {
-		return err
+	cfg := serverConfig{
+		Version: serverConfigVersion,
+		Aliases: entries,
 	}
-	aliasesJSON, err := json.Marshal(entries)
-	if err != nil {
-		return err
-	}
-	existing["version"] = versionJSON
-	existing["aliases"] = aliasesJSON

 	f, err := os.CreateTemp(dir, "router-*.json")
 	if err != nil {
@@ -154,7 +138,7 @@ func (s *store) saveLocked() error {

 	enc := json.NewEncoder(f)
 	enc.SetIndent("", "  ")
-	if err := enc.Encode(existing); err != nil {
+	if err := enc.Encode(cfg); err != nil {
 		_ = f.Close()
 		_ = os.Remove(f.Name())
 		return err
--- a/server/routes.go
+++ b/server/routes.go
@@ -38,7 +38,6 @@ import (
 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/format"
 	"github.com/ollama/ollama/fs/ggml"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
 	"github.com/ollama/ollama/llm"
 	"github.com/ollama/ollama/logutil"
 	"github.com/ollama/ollama/manifest"
@@ -59,11 +58,6 @@ import (

 const signinURLStr = "https://ollama.com/connect?name=%s&key=%s"

-const (
-	cloudErrRemoteInferenceUnavailable    = "remote model is unavailable"
-	cloudErrRemoteModelDetailsUnavailable = "remote model details are unavailable"
-)
-
 func shouldUseHarmony(model *Model) bool {
 	if slices.Contains([]string{"gptoss", "gpt-oss"}, model.Config.ModelFamily) {
 		// heuristic to check whether the template expects to be parsed via harmony:
@@ -235,11 +229,6 @@ func (s *Server) GenerateHandler(c *gin.Context) {
 	}

 	if m.Config.RemoteHost != "" && m.Config.RemoteModel != "" {
-		if disabled, _ := internalcloud.Status(); disabled {
-			c.JSON(http.StatusForbidden, gin.H{"error": internalcloud.DisabledError(cloudErrRemoteInferenceUnavailable)})
-			return
-		}
-
 		origModel := req.Model

 		remoteURL, err := url.Parse(m.Config.RemoteHost)
@@ -1077,12 +1066,9 @@ func (s *Server) ShowHandler(c *gin.Context) {

 	resp, err := GetModelInfo(req)
 	if err != nil {
-		var statusErr api.StatusError
 		switch {
 		case os.IsNotExist(err):
 			c.JSON(http.StatusNotFound, gin.H{"error": fmt.Sprintf("model '%s' not found", req.Model)})
-		case errors.As(err, &statusErr):
-			c.JSON(statusErr.StatusCode, gin.H{"error": statusErr.ErrorMessage})
 		case err.Error() == errtypes.InvalidModelNameErrMsg:
 			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		default:
@@ -1109,15 +1095,6 @@ func GetModelInfo(req api.ShowRequest) (*api.ShowResponse, error) {
 		return nil, err
 	}

-	if m.Config.RemoteHost != "" {
-		if disabled, _ := internalcloud.Status(); disabled {
-			return nil, api.StatusError{
-				StatusCode:   http.StatusForbidden,
-				ErrorMessage: internalcloud.DisabledError(cloudErrRemoteModelDetailsUnavailable),
-			}
-		}
-	}
-
 	modelDetails := api.ModelDetails{
 		ParentModel:       m.ParentModel,
 		Format:            m.Config.ModelFormat,
@@ -1594,7 +1571,6 @@ func (s *Server) GenerateRoutes(rc *ollama.Registry) (http.Handler, error) {
 	r.GET("/", func(c *gin.Context) { c.String(http.StatusOK, "Ollama is running") })
 	r.HEAD("/api/version", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"version": version.Version}) })
 	r.GET("/api/version", func(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"version": version.Version}) })
-	r.GET("/api/status", s.StatusHandler)

 	// Local model cache management (new implementation is at end of function)
 	r.POST("/api/pull", s.PullHandler)
@@ -1658,8 +1634,6 @@ func (s *Server) GenerateRoutes(rc *ollama.Registry) (http.Handler, error) {
 func Serve(ln net.Listener) error {
 	slog.SetDefault(logutil.NewLogger(os.Stderr, envconfig.LogLevel()))
 	slog.Info("server config", "env", envconfig.Values())
-	cloudDisabled, _ := internalcloud.Status()
-	slog.Info(fmt.Sprintf("Ollama cloud disabled: %t", cloudDisabled))

 	blobsDir, err := manifest.BlobsPath("")
 	if err != nil {
@@ -1850,16 +1824,6 @@ func streamResponse(c *gin.Context, ch chan any) {
 	})
 }

-func (s *Server) StatusHandler(c *gin.Context) {
-	disabled, source := internalcloud.Status()
-	c.JSON(http.StatusOK, api.StatusResponse{
-		Cloud: api.CloudStatus{
-			Disabled: disabled,
-			Source:   source,
-		},
-	})
-}
-
 func (s *Server) WhoamiHandler(c *gin.Context) {
 	// todo allow other hosts
 	u, err := url.Parse("https://ollama.com")
@@ -2046,11 +2010,6 @@ func (s *Server) ChatHandler(c *gin.Context) {
 	}

 	if m.Config.RemoteHost != "" && m.Config.RemoteModel != "" {
-		if disabled, _ := internalcloud.Status(); disabled {
-			c.JSON(http.StatusForbidden, gin.H{"error": internalcloud.DisabledError(cloudErrRemoteInferenceUnavailable)})
-			return
-		}
-
 		origModel := req.Model

 		remoteURL, err := url.Parse(m.Config.RemoteHost)
--- a/server/routes_aliases_test.go
+++ b/server/routes_aliases_test.go
@@ -5,7 +5,6 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
-	"os"
 	"path/filepath"
 	"testing"

@@ -17,7 +16,7 @@ import (

 func TestAliasShadowingRejected(t *testing.T) {
 	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
+	t.Setenv("HOME", t.TempDir())

 	s := Server{}
 	w := createRequest(t, s.CreateHandler, api.CreateRequest{
@@ -41,7 +40,7 @@ func TestAliasShadowingRejected(t *testing.T) {

 func TestAliasResolvesForChatRemote(t *testing.T) {
 	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
+	t.Setenv("HOME", t.TempDir())

 	var remoteModel string
 	rs := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -257,7 +256,7 @@ func TestPrefixAliasChain(t *testing.T) {

 func TestPrefixAliasCRUD(t *testing.T) {
 	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
+	t.Setenv("HOME", t.TempDir())

 	s := Server{}

@@ -365,7 +364,7 @@ func TestPrefixAliasCaseInsensitive(t *testing.T) {

 func TestPrefixAliasLocalModelPrecedence(t *testing.T) {
 	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
+	t.Setenv("HOME", t.TempDir())

 	s := Server{}

@@ -425,51 +424,3 @@ func TestPrefixAliasLocalModelPrecedence(t *testing.T) {
 		t.Fatalf("expected resolved name to be %q, got %q", expectedTarget.DisplayShortest(), resolved.DisplayShortest())
 	}
 }
-
-func TestAliasSavePreservesCloudDisable(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	tmpDir := t.TempDir()
-	setTestHome(t, tmpDir)
-
-	configPath := filepath.Join(tmpDir, ".ollama", "server.json")
-	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
-		t.Fatal(err)
-	}
-
-	initial := map[string]any{
-		"version":              serverConfigVersion,
-		"disable_ollama_cloud": true,
-		"aliases":              []aliasEntry{},
-	}
-	data, err := json.Marshal(initial)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(configPath, data, 0o644); err != nil {
-		t.Fatal(err)
-	}
-
-	s := Server{}
-	w := createRequest(t, s.CreateAliasHandler, aliasEntry{Alias: "alias-model", Target: "target-model"})
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected status 200, got %d: %s", w.Code, w.Body.String())
-	}
-
-	updated, err := os.ReadFile(configPath)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	var updatedCfg map[string]json.RawMessage
-	if err := json.Unmarshal(updated, &updatedCfg); err != nil {
-		t.Fatal(err)
-	}
-
-	raw, ok := updatedCfg["disable_ollama_cloud"]
-	if !ok {
-		t.Fatal("expected disable_ollama_cloud key to be preserved")
-	}
-	if string(raw) != "true" {
-		t.Fatalf("expected disable_ollama_cloud to remain true, got %s", string(raw))
-	}
-}
--- a/server/routes_cloud_test.go
+++ b/server/routes_cloud_test.go
@@ -1,94 +0,0 @@
-package server
-
-import (
-	"encoding/json"
-	"net/http"
-	"testing"
-
-	"github.com/gin-gonic/gin"
-	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
-)
-
-func TestStatusHandler(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
-	t.Setenv("OLLAMA_NO_CLOUD", "1")
-
-	s := Server{}
-	w := createRequest(t, s.StatusHandler, nil)
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected status 200, got %d", w.Code)
-	}
-
-	var resp api.StatusResponse
-	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
-		t.Fatal(err)
-	}
-
-	if !resp.Cloud.Disabled {
-		t.Fatalf("expected cloud.disabled true, got false")
-	}
-	if resp.Cloud.Source != "env" {
-		t.Fatalf("expected cloud.source env, got %q", resp.Cloud.Source)
-	}
-}
-
-func TestCloudDisabledBlocksRemoteOperations(t *testing.T) {
-	gin.SetMode(gin.TestMode)
-	setTestHome(t, t.TempDir())
-	t.Setenv("OLLAMA_NO_CLOUD", "1")
-
-	s := Server{}
-
-	w := createRequest(t, s.CreateHandler, api.CreateRequest{
-		Model:      "test-cloud",
-		RemoteHost: "example.com",
-		From:       "test",
-		Info: map[string]any{
-			"capabilities": []string{"completion"},
-		},
-		Stream: &stream,
-	})
-	if w.Code != http.StatusOK {
-		t.Fatalf("expected status 200, got %d", w.Code)
-	}
-
-	t.Run("chat remote blocked", func(t *testing.T) {
-		w := createRequest(t, s.ChatHandler, api.ChatRequest{
-			Model:    "test-cloud",
-			Messages: []api.Message{{Role: "user", Content: "hi"}},
-		})
-		if w.Code != http.StatusForbidden {
-			t.Fatalf("expected status 403, got %d", w.Code)
-		}
-		if got := w.Body.String(); got != `{"error":"`+internalcloud.DisabledError(cloudErrRemoteInferenceUnavailable)+`"}` {
-			t.Fatalf("unexpected response: %s", got)
-		}
-	})
-
-	t.Run("generate remote blocked", func(t *testing.T) {
-		w := createRequest(t, s.GenerateHandler, api.GenerateRequest{
-			Model:  "test-cloud",
-			Prompt: "hi",
-		})
-		if w.Code != http.StatusForbidden {
-			t.Fatalf("expected status 403, got %d", w.Code)
-		}
-		if got := w.Body.String(); got != `{"error":"`+internalcloud.DisabledError(cloudErrRemoteInferenceUnavailable)+`"}` {
-			t.Fatalf("unexpected response: %s", got)
-		}
-	})
-
-	t.Run("show remote blocked", func(t *testing.T) {
-		w := createRequest(t, s.ShowHandler, api.ShowRequest{
-			Model: "test-cloud",
-		})
-		if w.Code != http.StatusForbidden {
-			t.Fatalf("expected status 403, got %d", w.Code)
-		}
-		if got := w.Body.String(); got != `{"error":"`+internalcloud.DisabledError(cloudErrRemoteModelDetailsUnavailable)+`"}` {
-			t.Fatalf("unexpected response: %s", got)
-		}
-	})
-}
--- a/server/test_home_test.go
+++ b/server/test_home_test.go
@@ -1,14 +0,0 @@
-package server
-
-import (
-	"testing"
-
-	"github.com/ollama/ollama/envconfig"
-)
-
-func setTestHome(t *testing.T, home string) {
-	t.Helper()
-	t.Setenv("HOME", home)
-	t.Setenv("USERPROFILE", home)
-	envconfig.ReloadServerConfig()
-}
--- a/x/cmd/run.go
+++ b/x/cmd/run.go
@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"net/http"
 	"net/url"
 	"os"
 	"os/signal"
@@ -19,7 +18,6 @@ import (
 	"golang.org/x/term"

 	"github.com/ollama/ollama/api"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
 	"github.com/ollama/ollama/progress"
 	"github.com/ollama/ollama/readline"
 	"github.com/ollama/ollama/types/model"
@@ -64,18 +62,6 @@ func isLocalServer() bool {
 	return hostname == "localhost" || hostname == "127.0.0.1" || strings.Contains(parsed.Host, ":11434")
 }

-func cloudStatusDisabled(ctx context.Context, client *api.Client) (disabled bool, known bool) {
-	status, err := client.CloudStatusExperimental(ctx)
-	if err != nil {
-		var statusErr api.StatusError
-		if errors.As(err, &statusErr) && statusErr.StatusCode == http.StatusNotFound {
-			return false, false
-		}
-		return false, false
-	}
-	return status.Cloud.Disabled, true
-}
-
 // truncateToolOutput truncates tool output to prevent context overflow.
 // Uses a smaller limit (4k tokens) for local models, larger (10k) for cloud/remote.
 func truncateToolOutput(output, modelName string) string {
@@ -100,10 +86,6 @@ func waitForOllamaSignin(ctx context.Context) error {
 		return err
 	}

-	if disabled, known := cloudStatusDisabled(ctx, client); known && disabled {
-		return errors.New(internalcloud.DisabledError("cloud account endpoints are unavailable"))
-	}
-
 	// Get signin URL from initial Whoami call
 	_, err = client.Whoami(ctx)
 	if err != nil {
@@ -682,15 +664,6 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op
 		supportsTools = false
 	}

-	if enableWebsearch {
-		if client, err := api.ClientFromEnvironment(); err == nil {
-			if disabled, known := cloudStatusDisabled(cmd.Context(), client); known && disabled {
-				fmt.Fprintf(os.Stderr, "%s\n", internalcloud.DisabledError("web search is unavailable"))
-				enableWebsearch = false
-			}
-		}
-	}
-
 	// Create tool registry only if model supports tools
 	var toolRegistry *tools.Registry
 	if supportsTools {
--- a/x/imagegen/server.go
+++ b/x/imagegen/server.go
@@ -21,7 +21,6 @@ import (
 	"sync"
 	"time"

-	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/llm"
 	"github.com/ollama/ollama/ml"
 	"github.com/ollama/ollama/x/imagegen/manifest"
@@ -196,7 +195,7 @@ func (s *Server) Ping(ctx context.Context) error {
 // waitUntilRunning waits for the subprocess to be ready.
 func (s *Server) waitUntilRunning() error {
 	ctx := context.Background()
-	timeout := time.After(envconfig.LoadTimeout())
+	timeout := time.After(2 * time.Minute)
 	ticker := time.NewTicker(100 * time.Millisecond)
 	defer ticker.Stop()

--- a/x/imagegen/transfer/upload.go
+++ b/x/imagegen/transfer/upload.go
@@ -155,6 +155,9 @@ func (u *uploader) uploadOnce(ctx context.Context, blob Blob) (int64, error) {
 	if err != nil {
 		return 0, err
 	}
+	if uploadURL == "" {
+		return 0, nil // blob already exists
+	}

 	// Open file
 	f, err := os.Open(filepath.Join(u.srcDir, digestToPath(blob.Digest)))
@@ -217,6 +220,10 @@ func (u *uploader) initUpload(ctx context.Context, blob Blob) (string, error) {
 		return u.initUpload(ctx, blob)
 	}

+	if resp.StatusCode == http.StatusCreated {
+		return "", nil // blob already exists
+	}
+
 	if resp.StatusCode != http.StatusAccepted {
 		return "", fmt.Errorf("init: status %d", resp.StatusCode)
 	}
--- a/x/mlxrunner/mlx/dynamic.go
+++ b/x/mlxrunner/mlx/dynamic.go
@@ -8,7 +8,6 @@ package mlx
 import "C"

 import (
-	"fmt"
 	"io/fs"
 	"log/slog"
 	"os"
@@ -17,13 +16,6 @@ import (
 	"unsafe"
 )

-var initError error
-
-// CheckInit returns any error that occurred during MLX dynamic library initialization.
-func CheckInit() error {
-	return initError
-}
-
 func init() {
 	switch runtime.GOOS {
 	case "darwin":
@@ -42,9 +34,7 @@ func init() {
 	for _, path := range filepath.SplitList(paths) {
 		matches, err := fs.Glob(os.DirFS(path), "libmlxc.*")
 		if err != nil {
-			initError = fmt.Errorf("failed to glob for MLX libraries in %s: %w", path, err)
-			slog.Warn("MLX dynamic library not available", "error", initError)
-			return
+			panic(err)
 		}

 		for _, match := range matches {
@@ -71,6 +61,5 @@ func init() {
 		}
 	}

-	initError = fmt.Errorf("failed to load any MLX dynamic library from OLLAMA_LIBRARY_PATH=%s", paths)
-	slog.Warn("MLX dynamic library not available", "error", initError)
+	panic("Failed to load any MLX dynamic library")
 }
--- a/x/mlxrunner/server.go
+++ b/x/mlxrunner/server.go
@@ -7,7 +7,6 @@ import (
 	"cmp"
 	"encoding/json"
 	"flag"
-	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
@@ -17,17 +16,12 @@ import (

 	"github.com/ollama/ollama/envconfig"
 	"github.com/ollama/ollama/logutil"
-	"github.com/ollama/ollama/x/mlxrunner/mlx"
 	"github.com/ollama/ollama/x/mlxrunner/sample"
 )

 func Execute(args []string) error {
 	slog.SetDefault(logutil.NewLogger(os.Stderr, envconfig.LogLevel()))

-	if err := mlx.CheckInit(); err != nil {
-		return fmt.Errorf("MLX not available: %w", err)
-	}
-
 	var (
 		modelName string
 		port      int
--- a/x/tools/webfetch.go
+++ b/x/tools/webfetch.go
@@ -15,7 +15,6 @@ import (

 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/auth"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
 )

 const (
@@ -72,10 +71,6 @@ type webFetchResponse struct {
 // Execute fetches content from a web page.
 // Uses Ollama key signing for authentication - this makes requests via ollama.com API.
 func (w *WebFetchTool) Execute(args map[string]any) (string, error) {
-	if internalcloud.Disabled() {
-		return "", errors.New(internalcloud.DisabledError("web fetch is unavailable"))
-	}
-
 	urlStr, ok := args["url"].(string)
 	if !ok || urlStr == "" {
 		return "", fmt.Errorf("url parameter is required")
--- a/x/tools/websearch.go
+++ b/x/tools/websearch.go
@@ -15,7 +15,6 @@ import (

 	"github.com/ollama/ollama/api"
 	"github.com/ollama/ollama/auth"
-	internalcloud "github.com/ollama/ollama/internal/cloud"
 )

 const (
@@ -78,10 +77,6 @@ type webSearchResult struct {
 // Execute performs the web search.
 // Uses Ollama key signing for authentication - this makes requests via ollama.com API.
 func (w *WebSearchTool) Execute(args map[string]any) (string, error) {
-	if internalcloud.Disabled() {
-		return "", errors.New(internalcloud.DisabledError("web search is unavailable"))
-	}
-
 	query, ok := args["query"].(string)
 	if !ok || query == "" {
 		return "", fmt.Errorf("query parameter is required")