launch: add hermes (#15569)

cmd/launch/command_test.go

@@ -58,6 +58,9 @@ func TestLaunchCmd(t *testing.T) {
 		if cmd.Long == "" {
 			t.Error("Long description should not be empty")
 		}
+		if !strings.Contains(cmd.Long, "hermes") {
+			t.Error("Long description should mention hermes")
+		}
 	})
 
 	t.Run("flags exist", func(t *testing.T) {

cmd/launch/hermes.go

@@ -0,0 +1,962 @@
+package launch
+
+import (
+	"bufio"
+	"bytes"
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	pathpkg "path"
+	"path/filepath"
+	"runtime"
+	"slices"
+	"strconv"
+	"strings"
+	"time"
+
+	"gopkg.in/yaml.v3"
+
+	"github.com/ollama/ollama/api"
+	"github.com/ollama/ollama/cmd/config"
+	"github.com/ollama/ollama/cmd/internal/fileutil"
+	"github.com/ollama/ollama/envconfig"
+)
+
+const (
+	hermesInstallScript     = "curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash -s -- --skip-setup"
+	hermesProviderName      = "Ollama"
+	hermesProviderKey       = "ollama-launch"
+	hermesLegacyKey         = "ollama"
+	hermesPlaceholderKey    = "ollama"
+	hermesGatewaySetupHint  = "hermes gateway setup"
+	hermesGatewaySetupTitle = "Connect a messaging app now?"
+)
+
+var (
+	hermesGOOS      = runtime.GOOS
+	hermesLookPath  = exec.LookPath
+	hermesCommand   = exec.Command
+	hermesUserHome  = os.UserHomeDir
+	hermesOllamaURL = envconfig.ConnectableHost
+)
+
+var hermesMessagingEnvGroups = [][]string{
+	{"TELEGRAM_BOT_TOKEN"},
+	{"DISCORD_BOT_TOKEN"},
+	{"SLACK_BOT_TOKEN"},
+	{"SIGNAL_ACCOUNT"},
+	{"EMAIL_ADDRESS"},
+	{"TWILIO_ACCOUNT_SID"},
+	{"MATRIX_ACCESS_TOKEN", "MATRIX_PASSWORD"},
+	{"MATTERMOST_TOKEN"},
+	{"WHATSAPP_PHONE_NUMBER_ID"},
+	{"DINGTALK_CLIENT_ID"},
+	{"FEISHU_APP_ID"},
+	{"WECOM_BOT_ID"},
+	{"WEIXIN_ACCOUNT_ID"},
+	{"BLUEBUBBLES_SERVER_URL"},
+	{"WEBHOOK_ENABLED"},
+}
+
+// Hermes is intentionally not an Editor integration: launch owns one primary
+// model and the local Ollama endpoint, while Hermes keeps its own discovery and
+// switching UX after startup.
+type Hermes struct{}
+
+type hermesConfigBackend struct {
+	displayPath string
+	read        func() ([]byte, error)
+	write       func([]byte) error
+}
+
+func (h *Hermes) String() string { return "Hermes Agent" }
+
+func (h *Hermes) Run(_ string, args []string) error {
+	// Hermes reads its primary model from config.yaml. launch configures that
+	// default model ahead of time so we can keep runtime invocation simple and
+	// still let Hermes discover additional models later via its own UX.
+	if hermesGOOS == "windows" {
+		return h.runWindows(args)
+	}
+
+	bin, err := h.findUnixBinary()
+	if err != nil {
+		return err
+	}
+	if err := h.runGatewaySetupPreflight(args, func() error {
+		return hermesAttachedCommand(bin, "gateway", "setup").Run()
+	}); err != nil {
+		return err
+	}
+	return hermesAttachedCommand(bin, args...).Run()
+}
+
+func (h *Hermes) Paths() []string {
+	backend, err := h.configBackend()
+	if err != nil {
+		return nil
+	}
+	return []string{backend.displayPath}
+}
+
+func (h *Hermes) Configure(model string) error {
+	backend, err := h.configBackend()
+	if err != nil {
+		return err
+	}
+
+	cfg := map[string]any{}
+	if data, err := backend.read(); err == nil {
+		if err := yaml.Unmarshal(data, &cfg); err != nil {
+			return fmt.Errorf("parse hermes config: %w", err)
+		}
+	} else if !os.IsNotExist(err) {
+		return err
+	}
+
+	modelSection, _ := cfg["model"].(map[string]any)
+	if modelSection == nil {
+		modelSection = make(map[string]any)
+	}
+	models := h.listModels(model)
+	applyHermesManagedProviders(cfg, hermesBaseURL(), model, models)
+
+	// launch writes the minimum provider/default-model settings needed to
+	// bootstrap Hermes against Ollama. The active provider stays on a
+	// launch-owned key so /model stays aligned with the launcher-managed entry,
+	// and the Ollama endpoint lives in providers: so the picker shows one row.
+	modelSection["provider"] = hermesProviderKey
+	modelSection["default"] = model
+	modelSection["base_url"] = hermesBaseURL()
+	modelSection["api_key"] = hermesPlaceholderKey
+	cfg["model"] = modelSection
+
+	// use Hermes' built-in web toolset for now.
+	// TODO(parthsareen): move this to using Ollama web search
+	cfg["toolsets"] = mergeHermesToolsets(cfg["toolsets"])
+
+	data, err := yaml.Marshal(cfg)
+	if err != nil {
+		return err
+	}
+	return backend.write(data)
+}
+
+func (h *Hermes) CurrentModel() string {
+	backend, err := h.configBackend()
+	if err != nil {
+		return ""
+	}
+	data, err := backend.read()
+	if err != nil {
+		return ""
+	}
+
+	cfg := map[string]any{}
+	if yaml.Unmarshal(data, &cfg) != nil {
+		return ""
+	}
+	return hermesManagedCurrentModel(cfg, hermesBaseURL())
+}
+
+func (h *Hermes) Onboard() error {
+	return config.MarkIntegrationOnboarded("hermes")
+}
+
+func (h *Hermes) RequiresInteractiveOnboarding() bool {
+	return false
+}
+
+func (h *Hermes) RefreshRuntimeAfterConfigure() error {
+	running, err := h.gatewayRunning()
+	if err != nil {
+		return fmt.Errorf("check Hermes gateway status: %w", err)
+	}
+	if !running {
+		return nil
+	}
+
+	fmt.Fprintf(os.Stderr, "%sRefreshing Hermes messaging gateway...%s\n", ansiGray, ansiReset)
+	if err := h.restartGateway(); err != nil {
+		return fmt.Errorf("restart Hermes gateway: %w", err)
+	}
+	fmt.Fprintln(os.Stderr)
+	return nil
+}
+
+func (h *Hermes) installed() bool {
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			return true
+		}
+		return h.wslHasHermes()
+	}
+
+	_, err := h.findUnixBinary()
+	return err == nil
+}
+
+func (h *Hermes) ensureInstalled() error {
+	if h.installed() {
+		return nil
+	}
+
+	if hermesGOOS == "windows" {
+		return h.ensureInstalledWindows()
+	}
+
+	var missing []string
+	for _, dep := range []string{"bash", "curl", "git"} {
+		if _, err := hermesLookPath(dep); err != nil {
+			missing = append(missing, dep)
+		}
+	}
+	if len(missing) > 0 {
+		return fmt.Errorf("Hermes is not installed and required dependencies are missing\n\nInstall the following first:\n  %s\n\nThen re-run:\n  ollama launch hermes", strings.Join(missing, "\n  "))
+	}
+
+	ok, err := ConfirmPrompt("Hermes is not installed. Install now?")
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return fmt.Errorf("hermes installation cancelled")
+	}
+
+	fmt.Fprintf(os.Stderr, "\nInstalling Hermes...\n")
+	if err := hermesAttachedCommand("bash", "-lc", hermesInstallScript).Run(); err != nil {
+		return fmt.Errorf("failed to install hermes: %w", err)
+	}
+
+	if !h.installed() {
+		return fmt.Errorf("hermes was installed but the binary was not found on PATH\n\nYou may need to restart your shell")
+	}
+
+	fmt.Fprintf(os.Stderr, "%sHermes installed successfully%s\n\n", ansiGreen, ansiReset)
+	return nil
+}
+
+func (h *Hermes) ensureInstalledWindows() error {
+	// Hermes upstream support is WSL-oriented, so Windows launch uses a hybrid
+	// WSL handoff that stays on the same install path as upstream Hermes.
+	if _, err := hermesLookPath("hermes"); err == nil {
+		return nil
+	}
+	if !h.wslAvailable() {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+	if h.wslHasHermes() {
+		return nil
+	}
+
+	ok, err := ConfirmPromptWithOptions("Hermes runs through WSL2 on Windows. Install it in WSL now?", ConfirmOptions{
+		YesLabel: "Use WSL",
+		NoLabel:  "Show manual steps",
+	})
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+
+	fmt.Fprintf(os.Stderr, "\nInstalling Hermes in WSL...\n")
+	if err := h.runWSL("bash", "-lc", hermesInstallScript); err != nil {
+		return hermesWindowsHint(fmt.Errorf("failed to install hermes in WSL: %w", err))
+	}
+	if !h.wslHasHermes() {
+		return hermesWindowsHint(fmt.Errorf("hermes install finished but the WSL binary was not found"))
+	}
+
+	fmt.Fprintf(os.Stderr, "%sHermes installed successfully in WSL%s\n\n", ansiGreen, ansiReset)
+	return nil
+}
+
+func (h *Hermes) listModels(defaultModel string) []string {
+	client := hermesOllamaClient()
+	resp, err := client.List(context.Background())
+	if err != nil {
+		return []string{defaultModel}
+	}
+
+	models := make([]string, 0, len(resp.Models)+1)
+	seen := make(map[string]struct{}, len(resp.Models)+1)
+	add := func(name string) {
+		name = strings.TrimSpace(name)
+		if name == "" {
+			return
+		}
+		if _, ok := seen[name]; ok {
+			return
+		}
+		seen[name] = struct{}{}
+		models = append(models, name)
+	}
+
+	add(defaultModel)
+	for _, entry := range resp.Models {
+		add(entry.Name)
+	}
+	if len(models) == 0 {
+		return []string{defaultModel}
+	}
+	return models
+}
+
+func (h *Hermes) findUnixBinary() (string, error) {
+	if path, err := hermesLookPath("hermes"); err == nil {
+		return path, nil
+	}
+
+	home, err := hermesUserHome()
+	if err != nil {
+		return "", err
+	}
+	fallback := filepath.Join(home, ".local", "bin", "hermes")
+	if _, err := os.Stat(fallback); err == nil {
+		return fallback, nil
+	}
+
+	return "", fmt.Errorf("hermes is not installed")
+}
+
+func (h *Hermes) runWindows(args []string) error {
+	if path, err := hermesLookPath("hermes"); err == nil {
+		if err := h.runGatewaySetupPreflight(args, func() error {
+			return hermesAttachedCommand(path, "gateway", "setup").Run()
+		}); err != nil {
+			return err
+		}
+		return hermesAttachedCommand(path, args...).Run()
+	}
+	if !h.wslAvailable() {
+		return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+	}
+	if err := h.runGatewaySetupPreflight(args, func() error {
+		return h.runWSL("hermes", "gateway", "setup")
+	}); err != nil {
+		return err
+	}
+	if err := h.runWSL(append([]string{"hermes"}, args...)...); err != nil {
+		return hermesWindowsHint(err)
+	}
+	return nil
+}
+
+func (h *Hermes) runWSL(args ...string) error {
+	if !h.wslAvailable() {
+		return fmt.Errorf("wsl.exe is not available")
+	}
+
+	return hermesAttachedCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).Run()
+}
+
+func (h *Hermes) runWSLCombinedOutput(args ...string) ([]byte, error) {
+	if !h.wslAvailable() {
+		return nil, fmt.Errorf("wsl.exe is not available")
+	}
+
+	return hermesCommand("wsl.exe", "bash", "-lc", shellQuoteArgs(args)).CombinedOutput()
+}
+
+func (h *Hermes) wslAvailable() bool {
+	_, err := hermesLookPath("wsl.exe")
+	return err == nil
+}
+
+func (h *Hermes) wslHasHermes() bool {
+	if !h.wslAvailable() {
+		return false
+	}
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", "command -v hermes >/dev/null 2>&1")
+	return cmd.Run() == nil
+}
+
+func (h *Hermes) configBackend() (*hermesConfigBackend, error) {
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			return hermesLocalConfigBackend()
+		}
+		if h.wslAvailable() {
+			return h.wslConfigBackend()
+		}
+	}
+	return hermesLocalConfigBackend()
+}
+
+func hermesConfigPath() (string, error) {
+	home, err := hermesUserHome()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".hermes", "config.yaml"), nil
+}
+
+func hermesLocalConfigBackend() (*hermesConfigBackend, error) {
+	configPath, err := hermesConfigPath()
+	if err != nil {
+		return nil, err
+	}
+	return &hermesConfigBackend{
+		displayPath: configPath,
+		read: func() ([]byte, error) {
+			return os.ReadFile(configPath)
+		},
+		write: func(data []byte) error {
+			if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
+				return err
+			}
+			return fileutil.WriteWithBackup(configPath, data)
+		},
+	}, nil
+}
+
+func (h *Hermes) wslConfigBackend() (*hermesConfigBackend, error) {
+	home, err := h.wslHome()
+	if err != nil {
+		return nil, err
+	}
+	configPath := pathpkg.Join(home, ".hermes", "config.yaml")
+	return &hermesConfigBackend{
+		displayPath: configPath,
+		read: func() ([]byte, error) {
+			return h.readWSLFile(configPath)
+		},
+		write: func(data []byte) error {
+			return h.writeWSLConfig(configPath, data)
+		},
+	}, nil
+}
+
+func (h *Hermes) wslHome() (string, error) {
+	if !h.wslAvailable() {
+		return "", fmt.Errorf("wsl.exe is not available")
+	}
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", `printf %s "$HOME"`)
+	out, err := cmd.Output()
+	if err != nil {
+		return "", err
+	}
+	home := strings.TrimSpace(string(out))
+	if home == "" {
+		return "", fmt.Errorf("could not resolve WSL home directory")
+	}
+	return home, nil
+}
+
+func (h *Hermes) readWSLFile(path string) ([]byte, error) {
+	pathArg := shellQuoteArgs([]string{path})
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", fmt.Sprintf("if [ -f %s ]; then cat %s; else exit 42; fi", pathArg, pathArg))
+	out, err := cmd.Output()
+	if err == nil {
+		return out, nil
+	}
+	var exitErr *exec.ExitError
+	if errors.As(err, &exitErr) && exitErr.ExitCode() == 42 {
+		return nil, os.ErrNotExist
+	}
+	return nil, err
+}
+
+func (h *Hermes) writeWSLConfig(path string, data []byte) error {
+	if existing, err := h.readWSLFile(path); err == nil {
+		if !bytes.Equal(existing, data) {
+			if err := hermesBackupData(path, existing); err != nil {
+				return fmt.Errorf("backup failed: %w", err)
+			}
+		}
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("read existing file: %w", err)
+	}
+
+	dir := pathpkg.Dir(path)
+	dirArg := shellQuoteArgs([]string{dir})
+	pathArg := shellQuoteArgs([]string{path})
+	script := fmt.Sprintf(
+		"dir=%s; path=%s; mkdir -p \"$dir\" && tmp=$(mktemp \"$dir/.tmp-XXXXXX\") && cat > \"$tmp\" && mv \"$tmp\" \"$path\"",
+		dirArg,
+		pathArg,
+	)
+	cmd := hermesCommand("wsl.exe", "bash", "-lc", script)
+	cmd.Stdin = bytes.NewReader(data)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		if msg := strings.TrimSpace(string(out)); msg != "" {
+			return fmt.Errorf("%w: %s", err, msg)
+		}
+		return err
+	}
+	return nil
+}
+
+func hermesBackupData(path string, data []byte) error {
+	if err := os.MkdirAll(fileutil.BackupDir(), 0o755); err != nil {
+		return err
+	}
+	backupPath := filepath.Join(fileutil.BackupDir(), fmt.Sprintf("%s.%d", filepath.Base(path), time.Now().Unix()))
+	return os.WriteFile(backupPath, data, 0o644)
+}
+
+func hermesBaseURL() string {
+	return strings.TrimRight(hermesOllamaURL().String(), "/") + "/v1"
+}
+
+func hermesEnvPath() (string, error) {
+	home, err := hermesUserHome()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(home, ".hermes", ".env"), nil
+}
+
+func (h *Hermes) runGatewaySetupPreflight(args []string, runSetup func() error) error {
+	if len(args) > 0 || !isInteractiveSession() || currentLaunchConfirmPolicy.yes || currentLaunchConfirmPolicy.requireYesMessage {
+		return nil
+	}
+	if h.messagingConfigured() {
+		return nil
+	}
+
+	fmt.Fprintf(os.Stderr, "\nHermes can message you on Telegram, Discord, Slack, and more.\n\n")
+	ok, err := ConfirmPromptWithOptions(hermesGatewaySetupTitle, ConfirmOptions{
+		YesLabel: "Yes",
+		NoLabel:  "Set up later",
+	})
+	if err != nil {
+		return err
+	}
+	if !ok {
+		return nil
+	}
+	if err := runSetup(); err != nil {
+		return fmt.Errorf("hermes messaging setup failed: %w\n\nTry running: %s", err, hermesGatewaySetupHint)
+	}
+	return nil
+}
+
+func (h *Hermes) messagingConfigured() bool {
+	envVars, err := h.gatewayEnvVars()
+	if err != nil {
+		return false
+	}
+	for _, group := range hermesMessagingEnvGroups {
+		for _, key := range group {
+			if strings.TrimSpace(envVars[key]) != "" {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+func (h *Hermes) gatewayEnvVars() (map[string]string, error) {
+	envVars := make(map[string]string)
+
+	data, err := h.readGatewayEnvFile()
+	switch {
+	case err == nil:
+		for key, value := range hermesParseEnvFile(data) {
+			envVars[key] = value
+		}
+	case os.IsNotExist(err):
+		// nothing persisted yet
+	default:
+		return nil, err
+	}
+
+	if h.usesLocalRuntimeEnv() {
+		for _, group := range hermesMessagingEnvGroups {
+			for _, key := range group {
+				if value, ok := os.LookupEnv(key); ok {
+					envVars[key] = value
+				}
+			}
+		}
+	}
+
+	return envVars, nil
+}
+
+func (h *Hermes) readGatewayEnvFile() ([]byte, error) {
+	if hermesGOOS == "windows" {
+		if _, err := hermesLookPath("hermes"); err == nil {
+			path, err := hermesEnvPath()
+			if err != nil {
+				return nil, err
+			}
+			return os.ReadFile(path)
+		}
+		if h.wslAvailable() {
+			home, err := h.wslHome()
+			if err != nil {
+				return nil, err
+			}
+			return h.readWSLFile(pathpkg.Join(home, ".hermes", ".env"))
+		}
+	}
+
+	path, err := hermesEnvPath()
+	if err != nil {
+		return nil, err
+	}
+	return os.ReadFile(path)
+}
+
+func (h *Hermes) usesLocalRuntimeEnv() bool {
+	if hermesGOOS != "windows" {
+		return true
+	}
+	_, err := hermesLookPath("hermes")
+	return err == nil
+}
+
+func (h *Hermes) gatewayRunning() (bool, error) {
+	status, err := h.gatewayStatusOutput()
+	if err != nil {
+		return false, err
+	}
+	return hermesGatewayStatusRunning(status), nil
+}
+
+func (h *Hermes) gatewayStatusOutput() (string, error) {
+	if hermesGOOS == "windows" {
+		if path, err := hermesLookPath("hermes"); err == nil {
+			out, err := hermesCommand(path, "gateway", "status").CombinedOutput()
+			return string(out), err
+		}
+		if !h.wslAvailable() {
+			return "", hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+		}
+		out, err := h.runWSLCombinedOutput("hermes", "gateway", "status")
+		return string(out), err
+	}
+
+	bin, err := h.findUnixBinary()
+	if err != nil {
+		return "", err
+	}
+	out, err := hermesCommand(bin, "gateway", "status").CombinedOutput()
+	return string(out), err
+}
+
+func (h *Hermes) restartGateway() error {
+	if hermesGOOS == "windows" {
+		if path, err := hermesLookPath("hermes"); err == nil {
+			return hermesAttachedCommand(path, "gateway", "restart").Run()
+		}
+		if !h.wslAvailable() {
+			return hermesWindowsHint(fmt.Errorf("hermes is not installed"))
+		}
+		if err := h.runWSL("hermes", "gateway", "restart"); err != nil {
+			return hermesWindowsHint(err)
+		}
+		return nil
+	}
+
+	bin, err := h.findUnixBinary()
+	if err != nil {
+		return err
+	}
+	return hermesAttachedCommand(bin, "gateway", "restart").Run()
+}
+
+func hermesGatewayStatusRunning(output string) bool {
+	status := strings.ToLower(output)
+	switch {
+	case strings.Contains(status, "gateway is not running"):
+		return false
+	case strings.Contains(status, "gateway service is stopped"):
+		return false
+	case strings.Contains(status, "gateway service is not loaded"):
+		return false
+	case strings.Contains(status, "gateway is running"):
+		return true
+	case strings.Contains(status, "gateway service is running"):
+		return true
+	case strings.Contains(status, "gateway service is loaded"):
+		return true
+	default:
+		return false
+	}
+}
+
+func hermesParseEnvFile(data []byte) map[string]string {
+	out := make(map[string]string)
+	scanner := bufio.NewScanner(bytes.NewReader(data))
+	for scanner.Scan() {
+		line := strings.TrimSpace(strings.TrimPrefix(scanner.Text(), "\ufeff"))
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		if strings.HasPrefix(line, "export ") {
+			line = strings.TrimSpace(strings.TrimPrefix(line, "export "))
+		}
+
+		key, value, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+
+		key = strings.TrimSpace(key)
+		if key == "" {
+			continue
+		}
+
+		value = strings.TrimSpace(value)
+		if len(value) >= 2 {
+			switch {
+			case value[0] == '"' && value[len(value)-1] == '"':
+				if unquoted, err := strconv.Unquote(value); err == nil {
+					value = unquoted
+				}
+			case value[0] == '\'' && value[len(value)-1] == '\'':
+				value = value[1 : len(value)-1]
+			}
+		}
+
+		out[key] = value
+	}
+	return out
+}
+
+func hermesOllamaClient() *api.Client {
+	// Hermes queries the same launch-resolved Ollama host that launch writes
+	// into config, so model discovery follows the configured endpoint.
+	return api.NewClient(hermesOllamaURL(), http.DefaultClient)
+}
+
+func applyHermesManagedProviders(cfg map[string]any, baseURL string, model string, models []string) {
+	providers := hermesUserProviders(cfg["providers"])
+	entry := hermesManagedProviderEntry(providers)
+	if entry == nil {
+		entry = make(map[string]any)
+	}
+	entry["name"] = hermesProviderName
+	entry["api"] = baseURL
+	entry["default_model"] = model
+	entry["models"] = hermesStringListAny(models)
+	providers[hermesProviderKey] = entry
+	delete(providers, hermesLegacyKey)
+	cfg["providers"] = providers
+
+	customProviders := hermesWithoutManagedCustomProviders(cfg["custom_providers"])
+	if len(customProviders) == 0 {
+		delete(cfg, "custom_providers")
+		return
+	}
+	cfg["custom_providers"] = customProviders
+}
+
+func hermesManagedCurrentModel(cfg map[string]any, baseURL string) string {
+	modelCfg, _ := cfg["model"].(map[string]any)
+	if modelCfg == nil {
+		return ""
+	}
+
+	provider, _ := modelCfg["provider"].(string)
+	if strings.TrimSpace(strings.ToLower(provider)) != hermesProviderKey {
+		return ""
+	}
+
+	configBaseURL, _ := modelCfg["base_url"].(string)
+	if hermesNormalizeURL(configBaseURL) != hermesNormalizeURL(baseURL) {
+		return ""
+	}
+
+	current, _ := modelCfg["default"].(string)
+	current = strings.TrimSpace(current)
+	if current == "" {
+		return ""
+	}
+
+	providers := hermesUserProviders(cfg["providers"])
+	entry, _ := providers[hermesProviderKey].(map[string]any)
+	if entry == nil {
+		return ""
+	}
+	if hermesHasManagedCustomProvider(cfg["custom_providers"]) {
+		return ""
+	}
+
+	apiURL, _ := entry["api"].(string)
+	if hermesNormalizeURL(apiURL) != hermesNormalizeURL(baseURL) {
+		return ""
+	}
+
+	defaultModel, _ := entry["default_model"].(string)
+	if strings.TrimSpace(defaultModel) != current {
+		return ""
+	}
+
+	return current
+}
+
+func hermesUserProviders(current any) map[string]any {
+	switch existing := current.(type) {
+	case map[string]any:
+		out := make(map[string]any, len(existing))
+		for key, value := range existing {
+			out[key] = value
+		}
+		return out
+	case map[any]any:
+		out := make(map[string]any, len(existing))
+		for key, value := range existing {
+			if s, ok := key.(string); ok {
+				out[s] = value
+			}
+		}
+		return out
+	default:
+		return make(map[string]any)
+	}
+}
+
+func hermesCustomProviders(current any) []any {
+	switch existing := current.(type) {
+	case []any:
+		return append([]any(nil), existing...)
+	case []map[string]any:
+		out := make([]any, 0, len(existing))
+		for _, entry := range existing {
+			out = append(out, entry)
+		}
+		return out
+	default:
+		return nil
+	}
+}
+
+func hermesManagedProviderEntry(providers map[string]any) map[string]any {
+	for _, key := range []string{hermesProviderKey, hermesLegacyKey} {
+		if entry, _ := providers[key].(map[string]any); entry != nil {
+			return entry
+		}
+	}
+	return nil
+}
+
+func hermesWithoutManagedCustomProviders(current any) []any {
+	customProviders := hermesCustomProviders(current)
+	preserved := make([]any, 0, len(customProviders))
+
+	for _, item := range customProviders {
+		entry, _ := item.(map[string]any)
+		if entry == nil {
+			preserved = append(preserved, item)
+			continue
+		}
+		if hermesManagedCustomProvider(entry) {
+			continue
+		}
+		preserved = append(preserved, entry)
+	}
+
+	return preserved
+}
+
+func hermesHasManagedCustomProvider(current any) bool {
+	for _, item := range hermesCustomProviders(current) {
+		entry, _ := item.(map[string]any)
+		if entry != nil && hermesManagedCustomProvider(entry) {
+			return true
+		}
+	}
+	return false
+}
+
+func hermesManagedCustomProvider(entry map[string]any) bool {
+	name, _ := entry["name"].(string)
+	return strings.EqualFold(strings.TrimSpace(name), hermesProviderName)
+}
+
+func hermesNormalizeURL(raw string) string {
+	return strings.TrimRight(strings.TrimSpace(raw), "/")
+}
+
+func hermesStringListAny(models []string) []any {
+	out := make([]any, 0, len(models))
+	for _, model := range dedupeModelList(models) {
+		model = strings.TrimSpace(model)
+		if model == "" {
+			continue
+		}
+		out = append(out, model)
+	}
+	return out
+}
+
+func mergeHermesToolsets(current any) any {
+	added := false
+	switch existing := current.(type) {
+	case []any:
+		out := make([]any, 0, len(existing)+1)
+		for _, item := range existing {
+			out = append(out, item)
+			if s, _ := item.(string); s == "web" {
+				added = true
+			}
+		}
+		if !added {
+			out = append(out, "web")
+		}
+		return out
+	case []string:
+		out := append([]string(nil), existing...)
+		if !slices.Contains(out, "web") {
+			out = append(out, "web")
+		}
+		asAny := make([]any, 0, len(out))
+		for _, item := range out {
+			asAny = append(asAny, item)
+		}
+		return asAny
+	case string:
+		if strings.TrimSpace(existing) == "" {
+			return []any{"hermes-cli", "web"}
+		}
+		parts := strings.Split(existing, ",")
+		out := make([]any, 0, len(parts)+1)
+		for _, part := range parts {
+			part = strings.TrimSpace(part)
+			if part == "" {
+				continue
+			}
+			if part == "web" {
+				added = true
+			}
+			out = append(out, part)
+		}
+		if !added {
+			out = append(out, "web")
+		}
+		return out
+	default:
+		return []any{"hermes-cli", "web"}
+	}
+}
+
+func shellQuoteArgs(args []string) string {
+	quoted := make([]string, 0, len(args))
+	for _, arg := range args {
+		quoted = append(quoted, "'"+strings.ReplaceAll(arg, "'", `'\''`)+"'")
+	}
+	return strings.Join(quoted, " ")
+}
+
+func hermesAttachedCommand(name string, args ...string) *exec.Cmd {
+	cmd := hermesCommand(name, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd
+}
+
+func hermesWindowsHint(err error) error {
+	if hermesGOOS != "windows" {
+		return err
+	}
+	return fmt.Errorf("%w\n\nHermes runs on Windows through WSL2.\nQuick setup: wsl --install\nInstaller docs: https://hermes-agent.nousresearch.com/docs/getting-started/installation/", err)
+}

cmd/launch/integrations_test.go

@@ -74,7 +74,7 @@ func TestIntegrationLookup(t *testing.T) {
 }
 
 func TestIntegrationRegistry(t *testing.T) {
-	expectedIntegrations := []string{"claude", "codex", "droid", "opencode"}
+	expectedIntegrations := []string{"claude", "codex", "droid", "opencode", "hermes"}
 
 	for _, name := range expectedIntegrations {
 		t.Run(name, func(t *testing.T) {
@@ -1509,27 +1509,13 @@ func TestListIntegrationInfos(t *testing.T) {
 		}
 	})
 
-	t.Run("sorted with custom order at end", func(t *testing.T) {
-		// integrationOrder entries (cline, opencode) should appear last, in that order.
-		// All other entries should be sorted alphabetically before them.
-		orderRank := make(map[string]int)
-		for i, name := range integrationOrder {
-			orderRank[name] = i + 1
-		}
-		for i := 1; i < len(infos); i++ {
-			aRank, bRank := orderRank[infos[i-1].Name], orderRank[infos[i].Name]
-			switch {
-			case aRank == 0 && bRank == 0:
-				if infos[i-1].Name >= infos[i].Name {
-					t.Errorf("non-ordered items not sorted: %q >= %q", infos[i-1].Name, infos[i].Name)
-				}
-			case aRank > 0 && bRank == 0:
-				t.Errorf("ordered item %q should come after non-ordered %q", infos[i-1].Name, infos[i].Name)
-			case aRank > 0 && bRank > 0:
-				if aRank >= bRank {
-					t.Errorf("ordered items wrong: %q (rank %d) before %q (rank %d)", infos[i-1].Name, aRank, infos[i].Name, bRank)
-				}
+	t.Run("follows launcher order", func(t *testing.T) {
+		got := make([]string, 0, len(infos))
+		for _, info := range infos {
+			got = append(got, info.Name)
 		}
+		if diff := compareStrings(got, integrationOrder); diff != "" {
+			t.Fatalf("launcher integration order mismatch: %s", diff)
 		}
 	})
 
@@ -1557,6 +1543,28 @@ func TestListIntegrationInfos(t *testing.T) {
 			}
 		}
 	})
+
+	t.Run("includes hermes", func(t *testing.T) {
+		for _, info := range infos {
+			if info.Name == "hermes" {
+				return
+			}
+		}
+		t.Fatal("expected hermes to be included in ListIntegrationInfos")
+	})
+
+	t.Run("hermes still resolves explicitly", func(t *testing.T) {
+		name, runner, err := LookupIntegration("hermes")
+		if err != nil {
+			t.Fatalf("expected explicit hermes integration lookup to work, got %v", err)
+		}
+		if name != "hermes" {
+			t.Fatalf("expected canonical name hermes, got %q", name)
+		}
+		if runner.String() == "" {
+			t.Fatal("expected hermes integration runner to be present")
+		}
+	})
 }
 
 func TestBuildModelList_Descriptions(t *testing.T) {
@@ -1645,6 +1653,7 @@ func TestIntegration_AutoInstallable(t *testing.T) {
 	}{
 		{"openclaw", true},
 		{"pi", true},
+		{"hermes", true},
 		{"claude", false},
 		{"codex", false},
 		{"opencode", false},

cmd/launch/launch.go

@@ -141,6 +141,36 @@ type Editor interface {
 	Models() []string
 }
 
+// ManagedSingleModel is the narrow launch-owned config path for integrations
+// like Hermes that have one primary model selected by launcher, need launcher
+// to persist minimal config, and still keep their own model discovery and
+// onboarding UX. This stays separate from Runner-only integrations and the
+// multi-model Editor flow so Hermes-specific behavior stays scoped to one path.
+type ManagedSingleModel interface {
+	Paths() []string
+	Configure(model string) error
+	CurrentModel() string
+	Onboard() error
+}
+
+// ManagedRuntimeRefresher lets managed integrations refresh any long-lived
+// background runtime after launch rewrites their config.
+type ManagedRuntimeRefresher interface {
+	RefreshRuntimeAfterConfigure() error
+}
+
+// ManagedOnboardingValidator lets managed integrations re-check saved
+// onboarding state when launcher needs a stronger live readiness signal.
+type ManagedOnboardingValidator interface {
+	OnboardingComplete() bool
+}
+
+// ManagedInteractiveOnboarding lets a managed integration declare whether its
+// onboarding step really requires an interactive terminal. Hermes does not.
+type ManagedInteractiveOnboarding interface {
+	RequiresInteractiveOnboarding() bool
+}
+
 type modelInfo struct {
 	Name        string
 	Remote      bool
@@ -177,6 +207,7 @@ Supported integrations:
   cline     Cline
   codex     Codex
   droid     Droid
+  hermes    Hermes Agent
   opencode  OpenCode
   openclaw  OpenClaw (aliases: clawdbot, moltbot)
   pi        Pi
@@ -186,6 +217,7 @@ Examples:
   ollama launch
   ollama launch claude
   ollama launch claude --model <model>
+  ollama launch hermes
   ollama launch droid --config (does not auto-launch)
   ollama launch codex -- -p myprofile (pass extra args to integration)
   ollama launch codex -- --sandbox workspace-write`,
@@ -308,36 +340,54 @@ func LaunchIntegration(ctx context.Context, req IntegrationLaunchRequest) error
 	if err != nil {
 		return err
 	}
+
+	policy := launchIntegrationPolicy(req)
+	if policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() && req.ModelOverride == "" {
+		return fmt.Errorf("headless --yes launch for %s requires --model <model>", name)
+	}
+
+	launchClient, saved, err := prepareIntegrationLaunch(name, policy)
+	if err != nil {
+		return err
+	}
+
+	if managed, ok := runner.(ManagedSingleModel); ok {
+		if err := EnsureIntegrationInstalled(name, runner); err != nil {
+			return err
+		}
+		return launchClient.launchManagedSingleIntegration(ctx, name, runner, managed, saved, req)
+	}
+
 	if !req.ConfigureOnly {
 		if err := EnsureIntegrationInstalled(name, runner); err != nil {
 			return err
 		}
 	}
 
-	var policy LaunchPolicy
-	// TUI does not set a policy, whereas ollama launch <app> does as it can have flags which change the behavior
-	if req.Policy == nil {
-		policy = defaultLaunchPolicy(isInteractiveSession(), false)
-	} else {
-		policy = *req.Policy
-	}
-
-	launchClient, err := newLauncherClient(policy)
-	if err != nil {
-		return err
-	}
-	saved, _ := loadStoredIntegrationConfig(name)
-	// In headless --yes mode we cannot prompt, so require an explicit --model.
-	if policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() && req.ModelOverride == "" {
-		return fmt.Errorf("headless --yes launch for %s requires --model <model>", name)
-	}
-
 	if editor, ok := runner.(Editor); ok {
 		return launchClient.launchEditorIntegration(ctx, name, runner, editor, saved, req)
 	}
 	return launchClient.launchSingleIntegration(ctx, name, runner, saved, req)
 }
 
+func launchIntegrationPolicy(req IntegrationLaunchRequest) LaunchPolicy {
+	// TUI does not set a policy, whereas ollama launch <app> does as it can
+	// have flags which change the behavior.
+	if req.Policy != nil {
+		return *req.Policy
+	}
+	return defaultLaunchPolicy(isInteractiveSession(), false)
+}
+
+func prepareIntegrationLaunch(name string, policy LaunchPolicy) (*launcherClient, *config.IntegrationConfig, error) {
+	launchClient, err := newLauncherClient(policy)
+	if err != nil {
+		return nil, nil, err
+	}
+	saved, _ := loadStoredIntegrationConfig(name)
+	return launchClient, saved, nil
+}
+
 func (c *launcherClient) buildLauncherState(ctx context.Context) (*LauncherState, error) {
 	_ = c.loadModelInventoryOnce(ctx)
 
@@ -368,10 +418,19 @@ func (c *launcherClient) buildLauncherIntegrationState(ctx context.Context, info
 	if err != nil {
 		return LauncherIntegrationState{}, err
 	}
-	currentModel, usable, err := c.launcherModelState(ctx, info.Name, integration.editor)
+	var currentModel string
+	var usable bool
+	if managed, ok := integration.spec.Runner.(ManagedSingleModel); ok {
+		currentModel, usable, err = c.launcherManagedModelState(ctx, info.Name, managed)
 		if err != nil {
 			return LauncherIntegrationState{}, err
 		}
+	} else {
+		currentModel, usable, err = c.launcherModelState(ctx, info.Name, integration.editor)
+		if err != nil {
+			return LauncherIntegrationState{}, err
+		}
+	}
 
 	return LauncherIntegrationState{
 		Name:            info.Name,
@@ -408,6 +467,28 @@ func (c *launcherClient) launcherModelState(ctx context.Context, name string, is
 	return model, usableErr == nil && usable, nil
 }
 
+func (c *launcherClient) launcherManagedModelState(ctx context.Context, name string, managed ManagedSingleModel) (string, bool, error) {
+	current := managed.CurrentModel()
+	if current == "" {
+		cfg, loadErr := loadStoredIntegrationConfig(name)
+		if loadErr == nil {
+			current = primaryModelFromConfig(cfg)
+		}
+		if current != "" {
+			return current, false, nil
+		}
+	}
+	if current == "" {
+		return "", false, nil
+	}
+
+	usable, err := c.savedModelUsable(ctx, current)
+	if err != nil {
+		return current, false, err
+	}
+	return current, usable, nil
+}
+
 func (c *launcherClient) resolveRunModel(ctx context.Context, req RunModelRequest) (string, error) {
 	current := config.LastModel()
 	if !req.ForcePicker && current != "" && c.policy.Confirm == LaunchConfirmAutoApprove && !isInteractiveSession() {
@@ -444,35 +525,15 @@ func (c *launcherClient) resolveRunModel(ctx context.Context, req RunModelReques
 }
 
 func (c *launcherClient) launchSingleIntegration(ctx context.Context, name string, runner Runner, saved *config.IntegrationConfig, req IntegrationLaunchRequest) error {
-	current := primaryModelFromConfig(saved)
-	target := req.ModelOverride
-	needsConfigure := req.ForceConfigure
-
-	if target == "" {
-		target = current
-		usable, err := c.savedModelUsable(ctx, target)
+	target, _, err := c.resolveSingleIntegrationTarget(ctx, runner, primaryModelFromConfig(saved), req)
 	if err != nil {
 		return err
 	}
-		if !usable {
-			needsConfigure = true
-		}
-	}
-
-	if needsConfigure {
-		selected, err := c.selectSingleModelWithSelector(ctx, fmt.Sprintf("Select model for %s:", runner), target, DefaultSingleSelector)
-		if err != nil {
-			return err
-		}
-		target = selected
-	} else if err := c.ensureModelsReady(ctx, []string{target}); err != nil {
-		return err
-	}
-
 	if target == "" {
 		return nil
 	}
 
+	current := primaryModelFromConfig(saved)
 	if target != current {
 		if err := config.SaveIntegration(name, []string{target}); err != nil {
 			return fmt.Errorf("failed to save: %w", err)
@@ -510,6 +571,102 @@ func (c *launcherClient) launchEditorIntegration(ctx context.Context, name strin
 	return launchAfterConfiguration(name, runner, models[0], req)
 }
 
+func (c *launcherClient) launchManagedSingleIntegration(ctx context.Context, name string, runner Runner, managed ManagedSingleModel, saved *config.IntegrationConfig, req IntegrationLaunchRequest) error {
+	current := managed.CurrentModel()
+	selectionCurrent := current
+	if selectionCurrent == "" {
+		selectionCurrent = primaryModelFromConfig(saved)
+	}
+
+	target, needsConfigure, err := c.resolveSingleIntegrationTarget(ctx, runner, selectionCurrent, req)
+	if err != nil {
+		return err
+	}
+	if target == "" {
+		return nil
+	}
+
+	if current == "" || needsConfigure || req.ModelOverride != "" || target != current {
+		if err := prepareManagedSingleIntegration(name, runner, managed, target); err != nil {
+			return err
+		}
+		if refresher, ok := managed.(ManagedRuntimeRefresher); ok {
+			if err := refresher.RefreshRuntimeAfterConfigure(); err != nil {
+				return err
+			}
+		}
+	}
+
+	if !managedIntegrationOnboarded(saved, managed) {
+		if !isInteractiveSession() && managedRequiresInteractiveOnboarding(managed) {
+			return fmt.Errorf("%s still needs interactive gateway setup; run 'ollama launch %s' in a terminal to finish onboarding", runner, name)
+		}
+		if err := managed.Onboard(); err != nil {
+			return err
+		}
+	}
+
+	if req.ConfigureOnly {
+		return nil
+	}
+
+	return runIntegration(runner, target, req.ExtraArgs)
+}
+
+func (c *launcherClient) resolveSingleIntegrationTarget(ctx context.Context, runner Runner, current string, req IntegrationLaunchRequest) (string, bool, error) {
+	target := req.ModelOverride
+	needsConfigure := req.ForceConfigure
+
+	if target == "" {
+		target = current
+		usable, err := c.savedModelUsable(ctx, target)
+		if err != nil {
+			return "", false, err
+		}
+		if !usable {
+			needsConfigure = true
+		}
+	}
+
+	if needsConfigure {
+		selected, err := c.selectSingleModelWithSelector(ctx, fmt.Sprintf("Select model for %s:", runner), target, DefaultSingleSelector)
+		if err != nil {
+			return "", false, err
+		}
+		target = selected
+	} else if err := c.ensureModelsReady(ctx, []string{target}); err != nil {
+		return "", false, err
+	}
+
+	return target, needsConfigure, nil
+}
+
+func savedIntegrationOnboarded(saved *config.IntegrationConfig) bool {
+	return saved != nil && saved.Onboarded
+}
+
+func managedIntegrationOnboarded(saved *config.IntegrationConfig, managed ManagedSingleModel) bool {
+	if !savedIntegrationOnboarded(saved) {
+		return false
+	}
+	validator, ok := managed.(ManagedOnboardingValidator)
+	if !ok {
+		return true
+	}
+	return validator.OnboardingComplete()
+}
+
+// Most managed integrations treat onboarding as an interactive terminal step.
+// Hermes opts out because its launch-owned onboarding is just bookkeeping, so
+// headless launches should not be blocked once config is already prepared.
+func managedRequiresInteractiveOnboarding(managed ManagedSingleModel) bool {
+	onboarding, ok := managed.(ManagedInteractiveOnboarding)
+	if !ok {
+		return true
+	}
+	return onboarding.RequiresInteractiveOnboarding()
+}
+
 func (c *launcherClient) selectSingleModelWithSelector(ctx context.Context, title, current string, selector SingleSelector) (string, error) {
 	if selector == nil {
 		return "", fmt.Errorf("no selector configured")

cmd/launch/launch_test.go

@@ -49,6 +49,55 @@ func (r *launcherSingleRunner) Run(model string, args []string) error {
 
 func (r *launcherSingleRunner) String() string { return "StubSingle" }
 
+type launcherManagedRunner struct {
+	paths              []string
+	currentModel       string
+	configured         []string
+	ranModel           string
+	onboarded          bool
+	onboardCalls       int
+	onboardingComplete bool
+	refreshCalls       int
+	refreshErr         error
+}
+
+func (r *launcherManagedRunner) Run(model string, args []string) error {
+	r.ranModel = model
+	return nil
+}
+
+func (r *launcherManagedRunner) String() string { return "StubManaged" }
+
+func (r *launcherManagedRunner) Paths() []string { return r.paths }
+
+func (r *launcherManagedRunner) Configure(model string) error {
+	r.configured = append(r.configured, model)
+	r.currentModel = model
+	return nil
+}
+
+func (r *launcherManagedRunner) CurrentModel() string { return r.currentModel }
+
+func (r *launcherManagedRunner) Onboard() error {
+	r.onboardCalls++
+	r.onboarded = true
+	r.onboardingComplete = true
+	return nil
+}
+
+func (r *launcherManagedRunner) OnboardingComplete() bool { return r.onboardingComplete }
+
+func (r *launcherManagedRunner) RefreshRuntimeAfterConfigure() error {
+	r.refreshCalls++
+	return r.refreshErr
+}
+
+type launcherHeadlessManagedRunner struct {
+	launcherManagedRunner
+}
+
+func (r *launcherHeadlessManagedRunner) RequiresInteractiveOnboarding() bool { return false }
+
 func setLaunchTestHome(t *testing.T, dir string) {
 	t.Helper()
 	t.Setenv("HOME", dir)
@@ -141,6 +190,448 @@ func TestDefaultLaunchPolicy(t *testing.T) {
 	}
 }
 
+func TestBuildLauncherState_ManagedSingleIntegrationUsesCurrentModel(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/tags":
+			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{currentModel: "gemma4"}
+	withIntegrationOverride(t, "pi", runner)
+
+	state, err := BuildLauncherState(context.Background())
+	if err != nil {
+		t.Fatalf("BuildLauncherState returned error: %v", err)
+	}
+
+	if state.Integrations["pi"].CurrentModel != "gemma4" {
+		t.Fatalf("expected managed current model from integration config, got %q", state.Integrations["pi"].CurrentModel)
+	}
+	if !state.Integrations["pi"].ModelUsable {
+		t.Fatal("expected managed current model to be usable")
+	}
+}
+
+func TestBuildLauncherState_ManagedSingleIntegrationShowsSavedModelWhenLiveConfigMissing(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/tags":
+			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	if err := config.SaveIntegration("pi", []string{"gemma4"}); err != nil {
+		t.Fatalf("failed to save managed integration config: %v", err)
+	}
+
+	runner := &launcherManagedRunner{}
+	withIntegrationOverride(t, "pi", runner)
+
+	state, err := BuildLauncherState(context.Background())
+	if err != nil {
+		t.Fatalf("BuildLauncherState returned error: %v", err)
+	}
+
+	if state.Integrations["pi"].CurrentModel != "gemma4" {
+		t.Fatalf("expected saved model to remain visible, got %q", state.Integrations["pi"].CurrentModel)
+	}
+	if state.Integrations["pi"].ModelUsable {
+		t.Fatal("expected missing live config to mark managed model unusable")
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationConfiguresOnboardsAndRuns(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/tags":
+			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{
+		paths: nil,
+	}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {
+		return "gemma4", nil
+	}
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		return true, nil
+	}
+
+	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {
+		t.Fatalf("LaunchIntegration returned error: %v", err)
+	}
+
+	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
+		t.Fatalf("configured models mismatch: %s", diff)
+	}
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected runtime refresh once after configure, got %d", runner.refreshCalls)
+	}
+	if runner.onboardCalls != 1 {
+		t.Fatalf("expected onboarding to run once, got %d", runner.onboardCalls)
+	}
+	if runner.ranModel != "gemma4" {
+		t.Fatalf("expected launch to run configured model, got %q", runner.ranModel)
+	}
+
+	saved, err := config.LoadIntegration("stubmanaged")
+	if err != nil {
+		t.Fatalf("failed to reload managed integration config: %v", err)
+	}
+	if diff := compareStrings(saved.Models, []string{"gemma4"}); diff != "" {
+		t.Fatalf("saved models mismatch: %s", diff)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationReOnboardsWhenSavedFlagIsStale(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/tags":
+			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{
+		currentModel:       "gemma4",
+		onboardingComplete: false,
+	}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {
+		t.Fatalf("failed to save managed integration config: %v", err)
+	}
+	if err := config.MarkIntegrationOnboarded("stubmanaged"); err != nil {
+		t.Fatalf("failed to mark managed integration onboarded: %v", err)
+	}
+
+	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {
+		t.Fatalf("LaunchIntegration returned error: %v", err)
+	}
+
+	if runner.onboardCalls != 1 {
+		t.Fatalf("expected stale onboarded flag to trigger onboarding, got %d calls", runner.onboardCalls)
+	}
+	if runner.refreshCalls != 0 {
+		t.Fatalf("expected no runtime refresh when config is unchanged, got %d", runner.refreshCalls)
+	}
+	if runner.ranModel != "gemma4" {
+		t.Fatalf("expected launch to run saved model after onboarding repair, got %q", runner.ranModel)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationConfigOnlySkipsFinalRun(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{
+		paths: nil,
+	}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		return true, nil
+	}
+
+	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
+		Name:          "stubmanaged",
+		ModelOverride: "gemma4",
+		ConfigureOnly: true,
+	}); err != nil {
+		t.Fatalf("LaunchIntegration returned error: %v", err)
+	}
+
+	if runner.ranModel != "" {
+		t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)
+	}
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected configure-only flow to refresh runtime once, got %d", runner.refreshCalls)
+	}
+	if runner.onboardCalls != 1 {
+		t.Fatalf("expected configure-only flow to onboard once, got %d", runner.onboardCalls)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationRepairsMissingLiveConfigUsingSavedModel(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/tags":
+			fmt.Fprint(w, `{"models":[{"name":"gemma4"}]}`)
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {
+		t.Fatalf("failed to save managed integration config: %v", err)
+	}
+
+	runner := &launcherManagedRunner{}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {
+		t.Fatal("selector should not be called when saved model is reused for repair")
+		return "", nil
+	}
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		return true, nil
+	}
+
+	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{Name: "stubmanaged"}); err != nil {
+		t.Fatalf("LaunchIntegration returned error: %v", err)
+	}
+
+	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
+		t.Fatalf("expected missing live config to be rewritten from saved model: %s", diff)
+	}
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected repaired config to refresh runtime once, got %d", runner.refreshCalls)
+	}
+	if runner.ranModel != "gemma4" {
+		t.Fatalf("expected launch to use repaired saved model, got %q", runner.ranModel)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationConfigureOnlyRepairsMissingLiveConfig(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	if err := config.SaveIntegration("stubmanaged", []string{"gemma4"}); err != nil {
+		t.Fatalf("failed to save managed integration config: %v", err)
+	}
+
+	runner := &launcherManagedRunner{}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	DefaultSingleSelector = func(title string, items []ModelItem, current string) (string, error) {
+		t.Fatal("selector should not be called when saved model is reused for repair")
+		return "", nil
+	}
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		return true, nil
+	}
+
+	if err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
+		Name:          "stubmanaged",
+		ConfigureOnly: true,
+	}); err != nil {
+		t.Fatalf("LaunchIntegration returned error: %v", err)
+	}
+
+	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
+		t.Fatalf("expected configure-only flow to rewrite missing live config: %s", diff)
+	}
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected configure-only repair to refresh runtime once, got %d", runner.refreshCalls)
+	}
+	if runner.ranModel != "" {
+		t.Fatalf("expected configure-only flow to skip final launch, got %q", runner.ranModel)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationStopsWhenRuntimeRefreshFails(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, true)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{
+		refreshErr: fmt.Errorf("boom"),
+	}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	DefaultConfirmPrompt = func(prompt string, options ConfirmOptions) (bool, error) {
+		return true, nil
+	}
+
+	err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
+		Name:          "stubmanaged",
+		ModelOverride: "gemma4",
+	})
+	if err == nil || !strings.Contains(err.Error(), "boom") {
+		t.Fatalf("expected runtime refresh error, got %v", err)
+	}
+	if runner.ranModel != "" {
+		t.Fatalf("expected final launch to stop on runtime refresh failure, got %q", runner.ranModel)
+	}
+	if runner.refreshCalls != 1 {
+		t.Fatalf("expected one runtime refresh attempt, got %d", runner.refreshCalls)
+	}
+	if runner.onboardCalls != 0 {
+		t.Fatalf("expected onboarding to stop after refresh failure, got %d", runner.onboardCalls)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationHeadlessNeedsInteractiveOnboarding(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, false)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherManagedRunner{
+		paths: nil,
+	}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
+		Name:          "stubmanaged",
+		ModelOverride: "gemma4",
+		Policy:        &LaunchPolicy{Confirm: LaunchConfirmAutoApprove, MissingModel: LaunchMissingModelAutoPull},
+	})
+	if err == nil {
+		t.Fatal("expected headless onboarding requirement to fail")
+	}
+	if !strings.Contains(err.Error(), "interactive gateway setup") {
+		t.Fatalf("expected interactive onboarding guidance, got %v", err)
+	}
+	if runner.ranModel != "" {
+		t.Fatalf("expected no final launch when onboarding is still required, got %q", runner.ranModel)
+	}
+	if runner.onboardCalls != 0 {
+		t.Fatalf("expected no onboarding attempts in headless mode, got %d", runner.onboardCalls)
+	}
+}
+
+func TestLaunchIntegration_ManagedSingleIntegrationHeadlessAllowsNonInteractiveOnboarding(t *testing.T) {
+	tmpDir := t.TempDir()
+	setLaunchTestHome(t, tmpDir)
+	withInteractiveSession(t, false)
+	withLauncherHooks(t)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.URL.Path {
+		case "/api/show":
+			fmt.Fprint(w, `{"model_info":{"general.context_length":131072}}`)
+		default:
+			http.NotFound(w, r)
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("OLLAMA_HOST", srv.URL)
+
+	runner := &launcherHeadlessManagedRunner{}
+	withIntegrationOverride(t, "stubmanaged", runner)
+
+	err := LaunchIntegration(context.Background(), IntegrationLaunchRequest{
+		Name:          "stubmanaged",
+		ModelOverride: "gemma4",
+		Policy:        &LaunchPolicy{Confirm: LaunchConfirmAutoApprove, MissingModel: LaunchMissingModelAutoPull},
+	})
+	if err != nil {
+		t.Fatalf("expected non-interactive onboarding to succeed headlessly, got %v", err)
+	}
+	if diff := compareStrings(runner.configured, []string{"gemma4"}); diff != "" {
+		t.Fatalf("configured models mismatch: %s", diff)
+	}
+	if runner.onboardCalls != 1 {
+		t.Fatalf("expected onboarding to run once, got %d", runner.onboardCalls)
+	}
+	if runner.ranModel != "gemma4" {
+		t.Fatalf("expected launch to run configured model, got %q", runner.ranModel)
+	}
+}
+
 func TestBuildLauncherState_InstalledAndCloudDisabled(t *testing.T) {
 	tmpDir := t.TempDir()
 	setLaunchTestHome(t, tmpDir)

cmd/launch/models.go

@@ -230,7 +230,7 @@ func pullMissingModel(ctx context.Context, client *api.Client, model string) err
 
 // prepareEditorIntegration persists models and applies editor-managed config files.
 func prepareEditorIntegration(name string, runner Runner, editor Editor, models []string) error {
-	if ok, err := confirmEditorEdit(runner, editor); err != nil {
+	if ok, err := confirmConfigEdit(runner, editor.Paths()); err != nil {
 		return err
 	} else if !ok {
 		return errCancelled
@@ -244,8 +244,22 @@ func prepareEditorIntegration(name string, runner Runner, editor Editor, models
 	return nil
 }
 
-func confirmEditorEdit(runner Runner, editor Editor) (bool, error) {
-	paths := editor.Paths()
+func prepareManagedSingleIntegration(name string, runner Runner, managed ManagedSingleModel, model string) error {
+	if ok, err := confirmConfigEdit(runner, managed.Paths()); err != nil {
+		return err
+	} else if !ok {
+		return errCancelled
+	}
+	if err := managed.Configure(model); err != nil {
+		return fmt.Errorf("setup failed: %w", err)
+	}
+	if err := config.SaveIntegration(name, []string{model}); err != nil {
+		return fmt.Errorf("failed to save: %w", err)
+	}
+	return nil
+}
+
+func confirmConfigEdit(runner Runner, paths []string) (bool, error) {
 	if len(paths) == 0 {
 		return true, nil
 	}

cmd/launch/registry.go

@@ -33,7 +33,7 @@ type IntegrationInfo struct {
 	Description string
 }
 
-var launcherIntegrationOrder = []string{"opencode", "droid", "pi"}
+var launcherIntegrationOrder = []string{"openclaw", "claude", "opencode", "hermes", "codex", "droid", "pi"}
 
 var integrationSpecs = []*IntegrationSpec{
 	{
@@ -136,6 +136,20 @@ var integrationSpecs = []*IntegrationSpec{
 			Command: []string{"npm", "install", "-g", "@mariozechner/pi-coding-agent@latest"},
 		},
 	},
+	{
+		Name:        "hermes",
+		Runner:      &Hermes{},
+		Description: "Self-improving AI agent built by Nous Research",
+		Install: IntegrationInstallSpec{
+			CheckInstalled: func() bool {
+				return (&Hermes{}).installed()
+			},
+			EnsureInstalled: func() error {
+				return (&Hermes{}).ensureInstalled()
+			},
+			URL: "https://hermes-agent.nousresearch.com/docs/getting-started/installation/",
+		},
+	},
 	{
 		Name:        "vscode",
 		Runner:      &VSCode{},
@@ -255,10 +269,10 @@ func ListVisibleIntegrationSpecs() []IntegrationSpec {
 			return aRank - bRank
 		}
 		if aRank > 0 {
-			return 1
+			return -1
 		}
 		if bRank > 0 {
-			return -1
+			return 1
 		}
 		return strings.Compare(a.Name, b.Name)
 	})

cmd/tui/tui.go

@@ -45,21 +45,12 @@ type menuItem struct {
 	isOthers    bool
 }
 
-var mainMenuItems = []menuItem{
-	{
+const pinnedIntegrationCount = 3
+
+var runModelMenuItem = menuItem{
 	title:       "Chat with a model",
 	description: "Start an interactive chat with a model",
 	isRunModel:  true,
-	},
-	{
-		integration: "openclaw",
-	},
-	{
-		integration: "claude",
-	},
-	{
-		integration: "opencode",
-	},
 }
 
 var othersMenuItem = menuItem{
@@ -102,20 +93,14 @@ func shouldExpandOthers(state *launch.LauncherState) bool {
 }
 
 func buildMenuItems(state *launch.LauncherState, showOthers bool) []menuItem {
-	items := make([]menuItem, 0, len(mainMenuItems)+1)
-	for _, item := range mainMenuItems {
-		if item.integration == "" {
-			items = append(items, item)
-			continue
-		}
-		if integrationState, ok := state.Integrations[item.integration]; ok {
-			items = append(items, integrationMenuItem(integrationState))
-		}
-	}
+	items := []menuItem{runModelMenuItem}
+	items = append(items, pinnedIntegrationItems(state)...)
 
-	if showOthers {
-		items = append(items, otherIntegrationItems(state)...)
-	} else {
+	otherItems := otherIntegrationItems(state)
+	switch {
+	case showOthers:
+		items = append(items, otherItems...)
+	case len(otherItems) > 0:
 		items = append(items, othersMenuItem)
 	}
 
@@ -135,17 +120,28 @@ func integrationMenuItem(state launch.LauncherIntegrationState) menuItem {
 }
 
 func otherIntegrationItems(state *launch.LauncherState) []menuItem {
-	pinned := map[string]bool{
-		"openclaw": true,
-		"claude":   true,
-		"opencode": true,
+	ordered := orderedIntegrationItems(state)
+	if len(ordered) <= pinnedIntegrationCount {
+		return nil
+	}
+	return ordered[pinnedIntegrationCount:]
+}
+
+func pinnedIntegrationItems(state *launch.LauncherState) []menuItem {
+	ordered := orderedIntegrationItems(state)
+	if len(ordered) <= pinnedIntegrationCount {
+		return ordered
+	}
+	return ordered[:pinnedIntegrationCount]
+}
+
+func orderedIntegrationItems(state *launch.LauncherState) []menuItem {
+	if state == nil {
+		return nil
 	}
 
-	var items []menuItem
+	items := make([]menuItem, 0, len(state.Integrations))
 	for _, info := range launch.ListIntegrationInfos() {
-		if pinned[info.Name] {
-			continue
-		}
 		integrationState, ok := state.Integrations[info.Name]
 		if !ok {
 			continue
@@ -155,6 +151,10 @@ func otherIntegrationItems(state *launch.LauncherState) []menuItem {
 	return items
 }
 
+func primaryMenuItemCount(state *launch.LauncherState) int {
+	return 1 + len(pinnedIntegrationItems(state))
+}
+
 func initialCursor(state *launch.LauncherState, items []menuItem) int {
 	if state == nil || state.LastSelection == "" {
 		return 0
@@ -190,7 +190,7 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 			if m.cursor > 0 {
 				m.cursor--
 			}
-			if m.showOthers && m.cursor < len(mainMenuItems) {
+			if m.showOthers && m.cursor < primaryMenuItemCount(m.state) {
 				m.showOthers = false
 				m.items = buildMenuItems(m.state, false)
 				m.cursor = min(m.cursor, len(m.items)-1)

cmd/tui/tui_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/google/go-cmp/cmp"
 	"github.com/ollama/ollama/cmd/launch"
 )
 
@@ -43,6 +44,13 @@ func launcherTestState() *launch.LauncherState {
 				Selectable:  true,
 				Changeable:  true,
 			},
+			"hermes": {
+				Name:        "hermes",
+				DisplayName: "Hermes Agent",
+				Description: "Self-improving AI agent built by Nous Research",
+				Selectable:  true,
+				Changeable:  true,
+			},
 			"droid": {
 				Name:        "droid",
 				DisplayName: "Droid",
@@ -70,8 +78,28 @@ func findMenuCursorByIntegration(items []menuItem, name string) int {
 	return -1
 }
 
+func integrationSequence(items []menuItem) []string {
+	sequence := make([]string, 0, len(items))
+	for _, item := range items {
+		switch {
+		case item.isRunModel:
+			sequence = append(sequence, "run")
+		case item.isOthers:
+			sequence = append(sequence, "more")
+		case item.integration != "":
+			sequence = append(sequence, item.integration)
+		}
+	}
+	return sequence
+}
+
+func compareStrings(got, want []string) string {
+	return cmp.Diff(want, got)
+}
+
 func TestMenuRendersPinnedItemsAndMore(t *testing.T) {
-	view := newModel(launcherTestState()).View()
+	menu := newModel(launcherTestState())
+	view := menu.View()
 	for _, want := range []string{"Chat with a model", "Launch OpenClaw", "Launch Claude Code", "Launch OpenCode", "More..."} {
 		if !strings.Contains(view, want) {
 			t.Fatalf("expected menu view to contain %q\n%s", want, view)
@@ -80,23 +108,31 @@ func TestMenuRendersPinnedItemsAndMore(t *testing.T) {
 	if strings.Contains(view, "Launch Codex") {
 		t.Fatalf("expected Codex to be under More, not pinned\n%s", view)
 	}
+	wantOrder := []string{"run", "openclaw", "claude", "opencode", "more"}
+	if diff := compareStrings(integrationSequence(menu.items), wantOrder); diff != "" {
+		t.Fatalf("unexpected pinned order: %s", diff)
+	}
 }
 
 func TestMenuExpandsOthersFromLastSelection(t *testing.T) {
 	state := launcherTestState()
-	state.LastSelection = "pi"
+	state.LastSelection = "codex"
 
 	menu := newModel(state)
 	if !menu.showOthers {
 		t.Fatal("expected others section to expand when last selection is in the overflow list")
 	}
 	view := menu.View()
-	if !strings.Contains(view, "Launch Pi") {
+	if !strings.Contains(view, "Launch Codex") {
 		t.Fatalf("expected expanded view to contain overflow integration\n%s", view)
 	}
 	if strings.Contains(view, "More...") {
 		t.Fatalf("expected expanded view to replace More... item\n%s", view)
 	}
+	wantOrder := []string{"run", "openclaw", "claude", "opencode", "hermes", "codex", "droid", "pi"}
+	if diff := compareStrings(integrationSequence(menu.items), wantOrder); diff != "" {
+		t.Fatalf("unexpected expanded order: %s", diff)
+	}
 }
 
 func TestMenuEnterOnRunSelectsRun(t *testing.T) {

docs/integrations/hermes.mdx

@@ -6,6 +6,10 @@ Hermes Agent is a self-improving AI agent built by Nous Research. It features au
 
 ## Quick start
 
+```bash
+ollama launch hermes
+```
+
 ### Pull a model
 
 Before running the setup wizard, make sure you have a model available. Hermes will auto-detect models downloaded through Ollama.

go.mod

@@ -106,5 +106,5 @@ require (
 	golang.org/x/term v0.36.0
 	golang.org/x/text v0.30.0
 	google.golang.org/protobuf v1.34.1
-	gopkg.in/yaml.v3 v3.0.1 // indirect
+	gopkg.in/yaml.v3 v3.0.1
 )